a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
StandardModel Class Reference

A model class for the Standard Model. More...

#include <StandardModel.h>

+ Inheritance diagram for StandardModel:

Detailed Description

A model class for the Standard Model.

Author
HEPfit Collaboration

This is a Model class containing parameters and functions associated with the Standard Model. This class is inherited from the QCD class, which defines parameters related to QCD.

Initialization

The constructor StandardModel() initializes some of the model flags to their default values. After creating an instance of the current class, it is required to call the initialization method InitializeModel(), which allocates memory to the pointers defined in the current class. These pointers are then used in computing EW precision and flavour observables, respectively. In the Monte Carlo run, the constructor as well as the initialization method are called in InputParser::ReadParameters().

The initializations and updates of the model parameters and flags are explained below.

Model parameters

The model parameters of StandardModel are summarized below:

Label LaTeX symbol Description
Mz \(M_Z\) The mass of the \(Z\) boson in GeV.
Mw_inp \(M_W\) The mass of the \(W\) boson in GeV. Only used if the flag MWinput is TRUE.
AlsMz \(\alpha_s(M_Z)\) The strong coupling constant at the Z-boson mass.
GF \(G_\mu\) The Fermi constant in \({\rm GeV}^{-2}\), measured through muon decays.
ale \(\alpha\) The fine-structure constant.
dAle5Mz \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\) The five-flavour hadronic contribution to the electromagnetic coupling.
mHl \(m_h\) The Higgs mass in GeV.
delMw \(\delta\,M_W\) The theoretical uncertainty in \(M_W\) in GeV, which is applicable only when EWSMApproximateFormulae::Mw() is employed for \(M_W\). See also the model flag Mw.
delSin2th_l \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\) The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), which is applicable only when EWSMApproximateFormulae::sin2thetaEff_l() is employed for \(\sin^2\theta_{\rm eff}^{\rm lept}\). See also the model flag KappaZ.
delSin2th_q \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\) The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), which is applicable only when EWSMApproximateFormulae::sin2thetaEff_q() is employed for \(\sin^2\theta_{\rm eff}^{q\not = b,t}\). See also the model flag KappaZ.
delSin2th_b \(\delta\sin^2\theta_{\rm eff}^{b}\) The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), which is applicable only when EWSMApproximateFormulae::sin2thetaEff_b() is employed for \(\sin^2\theta_{\rm eff}^{b}\). See also the model flag KappaZ.
delGammaZ \(\delta\,\Gamma_Z\) The theoretical uncertainty in \(\Gamma_Z\) in GeV, which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(\Gamma_Z\). See also the model flag NoApproximateGammaZ.
delsigma0H \(\delta\,\sigma_{Hadron}^0\) The theoretical uncertainty in \(\sigma_{Hadron}^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(\sigma_{Hadron}^0\).
delR0l \(\delta\,R_l^0\) The theoretical uncertainty in \(R_l^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(R_l^0\).
delR0c \(\delta\,R_c^0\) The theoretical uncertainty in \(R_c^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(R_c^0\).
delR0b \(\delta\,R_b^0\) The theoretical uncertainty in \(R_b^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(R_b^0\).
delGammaWlv \(\delta\,\Gamma_W_{l\nu}\) The theoretical uncertainty in \(\Gamma_W_{l\nu}\). RELATIVE uncertainty.
delGammaWqq \(\delta\,\Gamma_W_{qq}\) The theoretical uncertainty in \(\Gamma_W_{qq}\). RELATIVE uncertainty.
mneutrino_1 \(m_{\nu_1}\) The mass of the first-generation neutrino in GeV.
mneutrino_2 \(m_{\nu_2}\) The mass of the second-generation neutrino in GeV.
mneutrino_3 \(m_{\nu_3}\) The mass of the third-generation neutrino in GeV.
melectron \(m_e\) The electron mass in GeV.
mmu \(m_\mu\) The muon mass in GeV.
mtau \(m_\tau\) The tau mass in GeV.
lambda \(\lambda\) The CKM parameter \(\lambda\) in the Wolfenstein parameterization.
A \(A\) The CKM parameter \(A\) in the Wolfenstein parameterization.
rhob \(\bar{\rho}\) The CKM parameter \(\bar{\rho}\) in the Wolfenstein parameterization.
etab \(\bar{\eta}\) The CKM parameter \(\bar{\eta}\) in the Wolfenstein parameterization.
muw \(\mu_W\) A matching scale around the weak scale in GeV.

The set of the model parameters are initialized and updated with the methods Init() and Update(), respectively, where the former calls the latter actually. In Update(), the methods PreUpdate() and PostUpdate() are called to run all the procedures that are need to be executed before and after the model parameters are updated. The CKM and PMNS matrices and the Yukawa matrices are recomputed in PostUpdate() with the updated parameters. Inside the Update() method, the individual model parameter is assigned with the protected member function setParameter().

The parameters delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b, delGammaWlv, delGammaWqq represent theoretical uncertainties in the \(W\)-boson mass, the leptonic and quark effective weak mixing angles at the \(Z\)-boson mass scale, the total decay width of the \(Z\) boson, the hadronic cross section at the peak, the ratios \(R_l^0\), \(R_c^0\) and \(R_b^0\), and the \(W\)-boson partial decay widths into leptons and quarks, respectively, originating from missing higher-order corrections. The contributions from these parameters are incorporated into their two-loop approximate formulae: EWSMApproximateFormulae::Mw(), EWSMApproximateFormulae::sin2thetaEff_l(), EWSMApproximateFormulae::sin2thetaEff_q(), EWSMApproximateFormulae::sin2thetaEff_b(), EWSMApproximateFormulae::X_full_2_loop("GammaZ"), EWSMApproximateFormulae::X_full_2_loop("sigmaHadron"), EWSMApproximateFormulae::X_full_2_loop("R0_lepton"), EWSMApproximateFormulae::X_full_2_loop("R0_charm") and EWSMApproximateFormulae::X_full_2_loop("R0_bottom"). Therefore, the parameters are applicable only when the corresponding approximate formulae are employed. See also the model flags below.

Model flags

The flags of StandardModel are summarized below, where the values of the boolean flags (TRUE or FALSE) are case insensitive, while those of the other flags are case sensitive. The default values of the flags are indicated in bold:

Label Value Description
Wolfenstein TRUE / FALSE This flag controls the way the CKM matrix is parameterized. If set to TRUE, the CKM matrix is computed starting from the Wolfenstein parameters. If set to FALSE, the CKM matrix is computed starting from \(\vert V_{us} \vert\), \(\vert V_{cb} \vert\), \(\vert V_{ub} \vert\) and \(\gamma\). The default value is TRUE.
UseVud FALSE / TRUE This flag controls the way the CKM matrix is parameterized. If set to FALSE, with Wolfenstein FALSE, the CKM matrix is computed starting from \(\vert V_{us} \vert\), \(\vert V_{cb} \vert\), \(\vert V_{ub} \vert\) and \(\gamma\). If set to TRUE, with Wolfenstein FALSE, the CKM matrix is computed starting from \(\vert V_{ud} \vert\), \(\vert V_{cb} \vert\), \(\vert V_{ub} \vert\) and \(\gamma\). If Wolfenstein is set to TRUE, this flag has no effect. The default value is FALSE.
FixMuwMut FALSE / TRUE This flag controls the way the weak matching scale and the top quark decoupling scale are varied. If set to FALSE, the \(\mu_W\) parameter is introduced to float the matching scale independently of the top decoupling scale \(\mu_t\). If set to TRUE, the \(\mu_t\) parameter is fixed to \(\mu_W / M_W * \m_t\) Notice that in this case the \(\mu_t\) parameter defined in QCD becomes irrelevant, therefore it is advisable to fix it to a constant in the configuration file The default value is FALSE.
CacheInStandardModel TRUE / FALSE This flag controls the use of the cashing method implemented in EWSM class. The default value is TRUE.
CacheInEWSMcache TRUE / FALSE This flag controls the use of the cashing method implemented in EWSMcache class. The default value is TRUE.
WithoutNonUniversalVC TRUE / FALSE This flag controls if flavour non-universal vertex corrections are not added to the epsilon parameterization for the EW precision observables. The default value is FALSE; the non-universal corrections are taken into account.
NoApproximateGammaZ TRUE / FALSE This flag is set to true if the two-loop approximate formulae of the partial and total decay widths of the \(Z\) boson defined with the function EWSMApproximateFormulae::X_full_2_loop() are NOT employed. The default value is FALSE.
Mw NORESUM / OMSI / INTERMEDIATE / OMSII / APPROXIMATEFORMULA This flag controls the formula used in computing the \(W\)-boson mass. The default flag is APPROXIMATEFORMULA. See EWSM::Mw_SM(), EWSM::resumMw() and EWSMApproximateFormulae::Mw() for detail.
RhoZ NORESUM / OMSI / INTERMEDIATE / OMSII This flag controls the formula used in computing the \(Zf\bar{f}\) couplings \(\rho_Z^f\). The default flag is NORESUM. See EWSM::rhoZ_l_SM(), EWSM::rhoZ_q_SM() and EWSM::resumRhoZ() for detail.
KappaZ NORESUM / OMSI / INTERMEDIATE / OMSII / APPROXIMATEFORMULA This flag controls the formula used in computing the \(Zf\bar{f}\) couplings \(\kappa_Z^f\). The default flag is APPROXIMATEFORMULA. See EWSM::kappaZ_l_SM(), EWSM::kappaZ_q_SM() and EWSM::resumKappaZ() for detail.
MWinput TRUE / FALSE This auxiliary flag is used for setting the W mass as a SM input, instead of the electromagnetic constant parameter dAle5Mz. The default value is FALSE.
SMAux TRUE / FALSE This auxiliary flag is used for testing new options. The default value is FALSE.

These flags can be set via the method setFlag() or setFlagStr(), where the former is applicable for the boolean flags, while the latter is for the other flags. The method CheckFlags() is responsible for checking whether the flags are sane. The public member functions IsFlagWithoutNonUniversalVC(), IsFlagNoApproximateGammaZ() getFlagMw(), getFlagRhoZ() and getFlagKappaZ() are used to retrieve the values of each flag.

The first two flags CacheInStandardModel and CacheInEWSMcache for the cashing methods in EWSM and EWSMcache classes are relevant to the computations of the electroweak precision observables. Those caches are effective when the \(W\)-boson mass, the decay widths of the \(Z\) boson and the \(Zf\bar{f}\) effective couplings \(\kappa_Z^f\) are calculated without using their two-loop approximate formulae.

Notation

The on-mass-shell renormalization scheme [Sirlin:1980nh], [Marciano:1980pb], [Bardin:1980fe], [Bardin:1981sv] is adopted for UV divergences, and the weak mixing angle is defined in terms of the physical masses of the gauge bosons:

\[ s_W^2 \equiv \sin^2\theta_W = 1 - \frac{M_W^2}{M_Z^2}\,, \]

and \(c_W^2=1-s_W^2\).

The Fermi constant \(G_\mu\) in \(\mu\) decay is taken as an input quantity instead of the \(W\)-boson mass, since the latter has not been measured very precisely compared to the former. The relation between \(G_\mu\) and \(M_W\) is written as

\[ G_\mu = \frac{\pi\,\alpha}{\sqrt{2} s_W^2 M_W^2} (1+\Delta r)\,, \]

where \(\Delta r\) represents radiative corrections. From this relation, the \(W\)-boson mass is calculated as

\[ M_W^2 = \frac{M_Z^2}{2} \left( 1+\sqrt{1-\frac{4\pi\alpha}{\sqrt{2}G_\mu M_Z^2}\,(1+\Delta r)}\ \right). \]

The interaction between the \(Z\) boson and the neutral current can be written in terms of the effective \(Zf\bar{f}\) couplings \(g_{V}^f\) and \(g_{A}^f\), of \(g_{R}^f\) and \(g_{L}^f\), or of \(\rho_Z^f\) and \(\kappa_Z^f\):

\begin{eqnarray} \mathcal{L} &=& \frac{e}{2 s_W c_W}\, Z_\mu \sum_f \bar{f} \left( g_{V}^f\gamma_\mu - g_{A}^f \gamma_\mu\gamma_5 \right)\, f\,, \\ &=& \frac{e}{2s_W c_W}\, Z_\mu \sum_f \bar{f} \left[ g_{R}^f \gamma_\mu (1 + \gamma_5) + g_{L}^f \gamma_\mu (1 - \gamma_5) \right]\, f\,, \\ &=& \frac{e}{2 s_W c_W}\sqrt{\rho_Z^f}\, Z_\mu \sum_f \bar{f} \left[( I_3^f - 2Q_f\kappa_Z^f s_W^2)\gamma^\mu - I_3^f\gamma^\mu\gamma_5\right]\,f\,, \end{eqnarray}

where \(\rho_Z^f\) and \(\kappa_Z^f\) are related to \(g_{V}^f\) and \(g_{A}^f\) as the relations:

\begin{eqnarray} g_V^f &=& \sqrt{\rho_Z^f} I_3^f (1 - 4|Q_f|\kappa_Z^fs_W^2) = \sqrt{\rho_Z^f} (I_3^f - 2Q_f\kappa_Z^fs_W^2)\,, \qquad g_A^f &=& \sqrt{\rho_Z^f} I_3^f\,, \end{eqnarray}

and

\begin{eqnarray} \rho_Z^f &=& \left( \frac{g_A^f}{I_3^f} \right)^2, \qquad \kappa_Z^f &=& \frac{1}{4|Q_f|s_W^2} \left( 1 - \frac{g_V^{f}}{g_A^{f}}\right). \end{eqnarray}

Important member functions

The current class handles the following quantities:

  • \(M_W\)   (with Mw_SM()),
  • \(\Delta r\)   (with DeltaR_SM()),
  • \(c_W^2\) and \(s_W^2\)   (with cW2_SM() and sW2_SM()),
  • \(\Gamma_W\)   (with GammaW_SM()),
  • \(\rho_Z^f\)   (with rhoZ_l() and rhoZ_q()),
  • \(\kappa_Z^f\)   (with kappaZ_l() and kappaZ_q()),
  • \(g_V^f\)   (with gVl() and gVq()),
  • \(g_A^f\)   (with gAl() and gAq()),
  • \(\varepsilon_{1,2,3,b}\)   (with epsilon1_SM(), epsilon2_SM(), epsilon3_SM() and epsilonb_SM()).

Moreover, the functions Mzbar(), MwbarFromMw(), MwFromMwbar() and DeltaRbar_SM() can be used for the quantities in the complex-pole/fixed-width scheme.

Schemes

The formulae used for the \(W\)-boson mass \(M_W\) and the effective couplings \(\rho_Z^f\) and \(\kappa_Z^f\) are controlled with the model flags Mw, RhoZ and KappaZ of StandardModel. For each flag, the available schemes are as follows:

  • NORESUM:   No resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   the approximate two-loop formula given in EWSMApproximateFormulae class is employed.

The scheme APPROXIMATEFORMULA provides the most accurate SM predictions for \(M_W\) and \(\kappa_Z^f\), while the approximate two-loop formula is not available for \(\rho_Z^f\).

See resumMw(), resumRhoZ() and resumKappaZ() for details on the other schemes.

Caches

This class contains caching methods for the following functions: DeltaAlphaLepton(), DeltaAlpha(), Mw_SM(), GammaW_SM(), rhoZ_l_SM(), rhoZ_q_SM(), kappaZ_l_SM() and kappaZ_q_SM(), to improve the performance of the Monte Carlo run. The caching methods are implemented with the function checkSMparams().

The use of the caching methods can be controlled with the model flag CacheInStandardModel of StandardModel.

Definition at line 521 of file StandardModel.h.

Public Types

enum  LEP2RCs { Weak = 0 , WeakBox , ISR , QEDFSR , QCDFSR , NUMofLEP2RCs }
 
enum  orders_EW { EW1 = 0 , EW1QCD1 , EW1QCD2 , EW2 , EW2QCD1 , EW3 , orders_EW_size }
 An enumerated type representing perturbative orders of radiative corrections to EW precision observables. More...
 
- Public Types inherited from QCD
enum  lepton { NEUTRINO_1 , ELECTRON , NEUTRINO_2 , MU , NEUTRINO_3 , TAU , NOLEPTON }
 An enum type for leptons. More...
 
enum  meson { P_0 , P_P , K_0 , K_P , D_0 , D_P , D_S , B_D , B_P , B_S , B_C , PHI , K_star , K_star_P , K_S , D_star_P , RHO , RHO_P , OMEGA , MESON_END }
 An enum type for mesons. More...
 
enum  quark { UP , DOWN , CHARM , STRANGE , TOP , BOTTOM }
 An enum type for quarks. More...
 

Public Member Functions

virtual const double A_f (const Particle f) const
 The left-right asymmetry in \(e^+e^-\to Z\to \ell \bar{\ell}\) at the \(Z\)-pole, \(\mathcal{A}_\ell\). More...
 
virtual const double AFB (const Particle f) const
 
gslpp::complex AH_f (const double tau) const
 Fermionic loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings. More...
 
gslpp::complex AH_W (const double tau) const
 W loop function entering in the calculation of the effective \(H\gamma\gamma\) coupling. More...
 
gslpp::complex AHZga_f (const double tau, const double lambda) const
 Fermionic loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
gslpp::complex AHZga_W (const double tau, const double lambda) const
 W loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
const double Ale (double mu, orders order, bool Nf_thr=true) const
 The running electromagnetic coupling \(\alpha_e(\mu)\) in the \(\overline{MS}\) scheme. More...
 
const double ale_OS (const double mu, orders order=FULLNLO) const
 The running electromagnetic coupling \(\alpha(\mu)\) in the on-shell scheme. More...
 
virtual const double alphaMz () const
 The electromagnetic coupling at the \(Z\)-mass scale, \(\alpha(M_Z^2)=\alpha/(1-\Delta\alpha(M_Z^2))\). More...
 
virtual const double alrmoller (const double q2, const double y) const
 The computation of the parity violating asymmetry in Moller scattering. More...
 
const double Als (const double mu, const int Nf_in, const orders order=FULLNLO) const
 Computes the running strong coupling \(\alpha_s(\mu)\) with \(N_f\) active flavours in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda(). More...
 
const double Als (const double mu, const orders order, const bool Nf_thr, const bool qed_flag) const
 The running QCD coupling \(\alpha(\mu)\) in the \(\overline{MS}\) scheme including QED corrections. More...
 
const double Als (const double mu, const orders order=FULLNLO, const bool Nf_thr=true) const
 
const double Alstilde5 (const double mu) const
 The value of \(\frac{\alpha_s^{\mathrm{FULLNLO}}}{4\pi}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\) and full EW corrections. More...
 
virtual const double amuon () const
 The computation of the anomalous magnetic moment of the muon \(a_\mu=(g_\mu-2)/2\). More...
 
const double Beta_e (int nm, unsigned int nf) const
 QED beta function coefficients - eq. (36) hep-ph/0512066. More...
 
const double Beta_s (int nm, unsigned int nf) const
 QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066. More...
 
virtual const double BrHtobb () const
 The Br \((H\to b \bar{b})\) in the Standard Model. More...
 
virtual const double BrHtocc () const
 The Br \((H\to c \bar{c})\) in the Standard Model. More...
 
virtual const double BrHtogaga () const
 The Br \((H\to \gamma \gamma)\) in the Standard Model. More...
 
virtual const double BrHtogg () const
 The Br \(\(H\to gg)\) in the Standard Model. More...
 
virtual const double BrHtomumu () const
 The Br \((H\to \mu^+ \mu^-)\) in the Standard Model. More...
 
virtual const double BrHtoss () const
 The Br \((H\to s \bar{s})\) in the Standard Model. More...
 
virtual const double BrHtotautau () const
 The Br \((H\to \tau^+ \tau^-)\) in the Standard Model. More...
 
virtual const double BrHtoWWstar () const
 The Br \((H\to W W^*)\) in the Standard Model. More...
 
virtual const double BrHtoZga () const
 The Br \((H\to Z \gamma)\) in the Standard Model. More...
 
virtual const double BrHtoZZstar () const
 The Br \((H\to Z Z^*)\) in the Standard Model. More...
 
virtual const double BrW (const Particle fi, const Particle fj) const
 The branching ratio of the \(W\) boson decaying into a SM fermion pair, \(Br(W\to f_i f_j)\). More...
 
const double c02 () const
 The square of the cosine of the weak mixing angle \(c_0^2\) defined without weak radiative corrections. More...
 
virtual bool CheckFlags () const
 A method to check the sanity of the set of model flags. More...
 
virtual bool CheckParameters (const std::map< std::string, double > &DPars)
 A method to check if all the mandatory parameters for StandardModel have been provided in model initialization. More...
 
bool checkSMparamsForEWPO ()
 A method to check whether the parameters relevant to the EWPO are updated. More...
 
const double computeBrHto4f () const
 The Br \((H\to 4f)\) in the Standard Model. More...
 
const double computeBrHto4l2 () const
 The Br \((H\to 4l)\) \(l=e,\mu\) in the Standard Model. More...
 
const double computeBrHto4l3 () const
 The Br \((H\to 4l)\) \(l=e,\mu,\tau\) in the Standard Model. More...
 
const double computeBrHto4q () const
 The Br \((H\to 4q)\) in the Standard Model. More...
 
const double computeBrHto4v () const
 The Br \((H\to 4\nu)\) in the Standard Model. More...
 
const double computeBrHtobb () const
 The Br \((H\to bb)\) in the Standard Model. More...
 
const double computeBrHtocc () const
 The Br \((H\to cc)\) in the Standard Model. More...
 
const double computeBrHtoevmuv () const
 The Br \((H\to e \nu \mu \nu)\) in the Standard Model. More...
 
const double computeBrHtogaga () const
 The Br \((H\to\gamma\gamma)\) in the Standard Model. More...
 
const double computeBrHtogg () const
 The Br \((H\to gg)\) in the Standard Model. More...
 
const double computeBrHtollvv2 () const
 The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu\) in the Standard Model. More...
 
const double computeBrHtollvv3 () const
 The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu,\tau\) in the Standard Model. More...
 
const double computeBrHtomumu () const
 The Br \((H\to \mu\mu)\) in the Standard Model. More...
 
const double computeBrHtoss () const
 The Br \((H\to ss)\) in the Standard Model. More...
 
const double computeBrHtotautau () const
 The Br \((H\to \tau\tau)\) in the Standard Model. More...
 
const double computeBrHtoWW () const
 The Br \((H\to WW)\) in the Standard Model. More...
 
const double computeBrHtoZga () const
 The Br \((H\to Z\gamma)\) in the Standard Model. More...
 
const double computeBrHtoZZ () const
 The Br \((H\to ZZ)\) in the Standard Model. More...
 
void ComputeDeltaR_rem (const double Mw_i, double DeltaR_rem[orders_EW_size]) const
 A method to collect \(\Delta r_{\mathrm{rem}}\) computed via subclasses. More...
 
void ComputeDeltaRho (const double Mw_i, double DeltaRho[orders_EW_size]) const
 A method to collect \(\Delta\rho\) computed via subclasses. More...
 
const double computeGammaHgaga_tt () const
 The top loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
const double computeGammaHgaga_tW () const
 The mixed \(t-W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
const double computeGammaHgaga_WW () const
 The \(W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
const double computeGammaHgg_bb () const
 The bottom loop contribution to \(H\to gg\) in the Standard Model. More...
 
const double computeGammaHgg_tb () const
 The top-bottom interference contribution to \(H\to gg\) in the Standard Model. More...
 
const double computeGammaHgg_tt () const
 The top loop contribution to \(H\to gg\) in the Standard Model. More...
 
const double computeGammaHTotal () const
 The Higgs total width in the Standard Model. More...
 
const double computeGammaHZga_tt () const
 The top loop contribution to \(H\to Z\gamma\) in the Standard Model. More...
 
const double computeGammaHZga_tW () const
 The mixed \(t-W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. More...
 
const double computeGammaHZga_WW () const
 The \(W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. Currently it returns the value of tab 41 in ref. [Heinemeyer:2013tqa]. More...
 
const double computeSigmabbH (const double sqrt_s) const
 The bbH production cross section in the Standard Model. More...
 
const double computeSigmaggH (const double sqrt_s) const
 The ggH cross section in the Standard Model. More...
 
const double computeSigmaggH_bb (const double sqrt_s) const
 The square of the bottom-quark contribution to the ggH cross section in the Standard Model. More...
 
const double computeSigmaggH_tb (const double sqrt_s) const
 The top-bottom interference contribution to the ggH cross section in the Standard Model. More...
 
const double computeSigmaggH_tt (const double sqrt_s) const
 The square of the top-quark contribution to the ggH cross section in the Standard Model. More...
 
const double computeSigmatHq (const double sqrt_s) const
 The tHq production cross section in the Standard Model. More...
 
const double computeSigmattH (const double sqrt_s) const
 The ttH production cross section in the Standard Model. More...
 
const double computeSigmaVBF (const double sqrt_s) const
 The VBF cross section in the Standard Model. More...
 
const double computeSigmaWF (const double sqrt_s) const
 The W fusion contribution \(\sigma_{WF}\) to higgs-production cross section in the Standard Model. More...
 
const double computeSigmaWH (const double sqrt_s) const
 The WH production cross section in the Standard Model. More...
 
const double computeSigmaZF (const double sqrt_s) const
 The Z fusion contribution \(\sigma_{ZF}\) to higgs-production cross section in the Standard Model. More...
 
const double computeSigmaZH (const double sqrt_s) const
 The ZH production cross section in the Standard Model. More...
 
const double computeSigmaZWF (const double sqrt_s) const
 The Z W interference fusion contribution \(\sigma_{ZWF}\) to higgs-production cross section in the Standard Model. More...
 
virtual const double cW2 () const
 
virtual const double cW2 (const double Mw_i) const
 The square of the cosine of the weak mixing angle in the on-shell scheme, denoted as \(c_W^2\). More...
 
virtual const double Dalpha5hMz () const
 The 5-quark contribution to the running of the em constant to the \(Z\) pole. \(\Delta\alpha_{had}^{(5)}(M_Z)\). More...
 
const double DeltaAlpha () const
 The total corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha(M_Z^2)\). More...
 
const double DeltaAlphaL5q () const
 The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha^{\ell+5q}(M_Z^2)\). More...
 
const double DeltaAlphaLepton (const double s) const
 Leptonic contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{lept}}(s)\). More...
 
const double DeltaAlphaTop (const double s) const
 Top-quark contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{top}}(s)\). More...
 
virtual const gslpp::complex deltaKappaZ_f (const Particle f) const
 Flavour non-universal vertex corrections to \(\kappa_Z^l\), denoted by \(\Delta\kappa_Z^l\). More...
 
virtual const double DeltaR () const
 The SM prediction for \(\Delta r\) derived from that for the \(W\) boson mass. More...
 
virtual const double DeltaRbar () const
 The SM prediction for \(\Delta \overline{r}\) derived from that for the \(W\)-boson mass. More...
 
virtual const gslpp::complex deltaRhoZ_f (const Particle f) const
 Flavour non-universal vertex corrections to \(\rho_Z^l\), denoted by \(\Delta\rho_Z^l\). More...
 
virtual const double eeffAFBbottom (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBcharm (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBe (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBetsub (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBmu (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBstrange (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBtau (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRbottom (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRcharm (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRelectron (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRelectrontsub (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRmuon (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRstrange (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRtau (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigma (const Particle f, const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
 
virtual const double eeffsigmaBottom (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaCharm (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaE (const double pol_e, const double pol_p, const double s) const
 
const double eeffsigmaEbin (const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
 
virtual const double eeffsigmaEtsub (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaHadron (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaMu (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaStrange (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaTau (const double pol_e, const double pol_p, const double s) const
 
virtual const double epsilon1 () const
 The SM contribution to the epsilon parameter \(\varepsilon_1\). More...
 
virtual const double epsilon2 () const
 The SM contribution to the epsilon parameter \(\varepsilon_2\). More...
 
virtual const double epsilon3 () const
 The SM contribution to the epsilon parameter \(\varepsilon_3\). More...
 
virtual const double epsilonb () const
 The SM contribution to the epsilon parameter \(\varepsilon_b\). More...
 
gslpp::complex f_triangle (const double tau) const
 Loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings. More...
 
gslpp::complex g_triangle (const double tau) const
 Loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
virtual const gslpp::complex gA_f (const Particle f) const
 The effective leptonic neutral-current axial-vector coupling \(g_A^l\) in the SM. More...
 
virtual const double Gamma_had () const
 The hadronic decay width of the \(Z\) boson, \(\Gamma_{h}\). More...
 
virtual const double Gamma_inv () const
 The invisible partial decay width of the \(Z\) boson, \(\Gamma_{\mathrm{inv}}\). More...
 
virtual const double Gamma_muon () const
 The computation of the muon decay. More...
 
virtual const double Gamma_tau_l_nunu (const Particle l) const
 The computation of the leptonic tau decays. More...
 
virtual const double Gamma_Z () const
 The total decay width of the \(Z\) boson, \(\Gamma_Z\). More...
 
virtual const double GammaHtobb () const
 The \(\Gamma(H\to b \bar{b})\) in the Standard Model. More...
 
virtual const double GammaHtocc () const
 The \(\Gamma(H\to c \bar{c})\) in the Standard Model. More...
 
virtual const double GammaHtogaga () const
 The \(\Gamma(H\to \gamma \gamma)\) in the Standard Model. More...
 
virtual const double GammaHtogg () const
 The \(\Gamma(H\to gg)\) in the Standard Model. More...
 
virtual const double GammaHtomumu () const
 The \(\Gamma(H\to \mu^+ \mu^-)\) in the Standard Model. More...
 
virtual const double GammaHtoss () const
 The \(\Gamma(H\to s \bar{s})\) in the Standard Model. More...
 
virtual const double GammaHTot () const
 The total Higgs width \(\Gamma(H)\) in the Standard Model. More...
 
virtual const double GammaHtotautau () const
 The \(\Gamma(H\to \tau^+ \tau^-)\) in the Standard Model. More...
 
virtual const double GammaHtoWWstar () const
 The \(\Gamma(H\to W W^*)\) in the Standard Model. More...
 
virtual const double GammaHtoZga () const
 The \(\Gamma(H\to Z \gamma)\) in the Standard Model. More...
 
virtual const double GammaHtoZZstar () const
 The \(\Gamma(H\to Z Z^*)\) in the Standard Model. More...
 
virtual const double GammaW () const
 The total width of the \(W\) boson, \(\Gamma_W\). More...
 
virtual const double GammaW (const Particle fi, const Particle fj) const
 A partial decay width of the \(W\) boson decay into a SM fermion pair. More...
 
virtual const double GammaZ (const Particle f) const
 The \(Z\to \ell\bar{\ell}\) partial decay width, \(\Gamma_\ell\). More...
 
virtual const double gAnue () const
 The effective (muon) neutrino-electron axial-vector coupling: gAnue. More...
 
const double getAle () const
 A get method to retrieve the fine-structure constant \(\alpha\). More...
 
const double getAlsMz () const
 A get method to access the value of \(\alpha_s(M_Z)\). More...
 
virtual const double getCBd () const
 The ratio of the absolute value of the $B_d$ mixing amplitude over the Standard Model value. More...
 
virtual const double getCBs () const
 The ratio of the absolute value of the $B_s$ mixing amplitude over the Standard Model value. More...
 
virtual const double getCCC1 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC2 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC3 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC4 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC5 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCDMK () const
 The ratio of the real part of the $K$ mixing amplitude over the Standard Model value. More...
 
virtual const double getCepsK () const
 The ratio of the imaginary part of the $K$ mixing amplitude over the Standard Model value. More...
 
const CKMgetCKM () const
 A get method to retrieve the member object of type CKM. More...
 
const double getDAle5Mz () const
 A get method to retrieve the five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\). More...
 
const double getDelGammaWlv () const
 A get method to retrieve the theoretical uncertainty in \(\Gamma_W_{l\nu}\), denoted as \(\delta\,\Gamma_W_{l\nu}\). More...
 
const double getDelGammaWqq () const
 A get method to retrieve the theoretical uncertainty in \(\Gamma_W_{qq}\), denoted as \(\delta\,\Gamma_W_{qq}\). More...
 
const double getDelGammaZ () const
 A get method to retrieve the theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\). More...
 
const double getDelMw () const
 A get method to retrieve the theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\). More...
 
const double getDelR0b () const
 A get method to retrieve the theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\). More...
 
const double getDelR0c () const
 A get method to retrieve the theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\). More...
 
const double getDelR0l () const
 A get method to retrieve the theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\). More...
 
const double getDelSigma0H () const
 A get method to retrieve the theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\). More...
 
const double getDelSin2th_b () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\). More...
 
const double getDelSin2th_l () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\). More...
 
const double getDelSin2th_q () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\). More...
 
const std::string getFlagKappaZ () const
 A method to retrieve the model flag KappaZ. More...
 
const std::string getFlagMw () const
 A method to retrieve the model flag Mw. More...
 
const std::string getFlagRhoZ () const
 A method to retrieve the model flag RhoZ. More...
 
const FlavourgetFlavour () const
 
const double getGF () const
 A get method to retrieve the Fermi constant \(G_\mu\). More...
 
const int getIterationNo () const
 
const ParticlegetLeptons (const QCD::lepton p) const
 A get method to retrieve the member object of a lepton. More...
 
virtual StandardModelMatchinggetMatching () const
 A get method to access the member reference of type StandardModelMatching. More...
 
virtual const double getMHl () const
 A get method to retrieve the Higgs mass \(m_h\). More...
 
virtual const double getmq (const QCD::quark q, const double mu) const
 The MSbar running quark mass computed at NLO. More...
 
const double getMuw () const
 A get method to retrieve the matching scale \(\mu_W\) around the weak scale. More...
 
const double getMw () const
 A get method to access the input value of the mass of the \(W\) boson \(M_W\). More...
 
EWSMApproximateFormulaegetMyApproximateFormulae () const
 A get method to retrieve the member pointer of type EWSMApproximateFormulae. More...
 
EWSMcachegetMyEWSMcache () const
 A get method to retrieve the member pointer of type EWSMcache. More...
 
LeptonFlavourgetMyLeptonFlavour () const
 
EWSMOneLoopEWgetMyOneLoopEW () const
 A get method to retrieve the member pointer of type EWSMOneLoopEW,. More...
 
EWSMThreeLoopEWgetMyThreeLoopEW () const
 
EWSMThreeLoopEW2QCDgetMyThreeLoopEW2QCD () const
 
EWSMThreeLoopQCDgetMyThreeLoopQCD () const
 
EWSMTwoFermionsLEP2getMyTwoFermionsLEP2 () const
 A get method to retrieve the member pointer of type EWSMTwoFermionsLEP2. More...
 
EWSMTwoLoopEWgetMyTwoLoopEW () const
 
EWSMTwoLoopQCDgetMyTwoLoopQCD () const
 
const double getMz () const
 A get method to access the mass of the \(Z\) boson \(M_Z\). More...
 
virtual const double getPhiBd () const
 Half the relative phase of the $B_d$ mixing amplitude w.r.t. the Standard Model one. More...
 
virtual const double getPhiBs () const
 Half the relative phase of the $B_s$ mixing amplitude w.r.t. the Standard Model one. More...
 
virtual const StandardModelgetTrueSM () const
 
const gslpp::matrix< gslpp::complex > getUPMNS () const
 A get method to retrieve the object of the PMNS matrix. More...
 
const gslpp::matrix< gslpp::complex > getVCKM () const
 A get method to retrieve the CKM matrix. More...
 
const gslpp::matrix< gslpp::complex > & getYd () const
 A get method to retrieve the Yukawa matrix of the down-type quarks, \(Y_d\). More...
 
const gslpp::matrix< gslpp::complex > & getYe () const
 A get method to retrieve the Yukawa matrix of the charged leptons, \(Y_e\). More...
 
const gslpp::matrix< gslpp::complex > & getYn () const
 A get method to retrieve the Yukawa matrix of the neutrinos, \(Y_\nu\). More...
 
const gslpp::matrix< gslpp::complex > & getYu () const
 A get method to retrieve the Yukawa matrix of the up-type quarks, \(Y_u\). More...
 
virtual const double gLnuN2 () const
 The effective neutrino nucleon LH coupling: gLnuN2. More...
 
virtual const double gRnuN2 () const
 The effective neutrino nucleon RH coupling: gRnuN2. More...
 
virtual const gslpp::complex gV_f (const Particle f) const
 The effective leptonic neutral-current vector coupling \(g_V^l\) in the SM. More...
 
virtual const double gVnue () const
 The effective (muon) neutrino-electron vector coupling: gVnue. More...
 
gslpp::complex I_triangle_1 (const double tau, const double lambda) const
 Loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
gslpp::complex I_triangle_2 (const double tau, const double lambda) const
 Loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
virtual bool Init (const std::map< std::string, double > &DPars)
 A method to initialize the model parameters. More...
 
virtual bool InitializeModel ()
 A method to initialize the model. More...
 
const double intMLL2eeeeus2 (const double s, const double t0, const double t1) const
 
const double intMLR2eeeets2 (const double s, const double t0, const double t1) const
 
const double intMLRtilde2eeeest2 (const double s, const double t0, const double t1) const
 
const double intMRR2eeeeus2 (const double s, const double t0, const double t1) const
 
const bool IsFlagNoApproximateGammaZ () const
 A method to retrieve the model flag NoApproximateGammaZ. More...
 
const bool IsFlagWithoutNonUniversalVC () const
 A method to retrieve the model flag WithoutNonUniversalVC. More...
 
const bool isSMSuccess () const
 A get method to retrieve the success status of the Standard Model update and matching. More...
 
virtual const gslpp::complex kappaZ_f (const Particle f) const
 The effective leptonic neutral-current coupling \(\kappa_Z^l\) in the SM. More...
 
virtual const double LEP2AFBbottom (const double s) const
 
virtual const double LEP2AFBcharm (const double s) const
 
virtual const double LEP2AFBe (const double s) const
 
virtual const double LEP2AFBmu (const double s) const
 
virtual const double LEP2AFBtau (const double s) const
 
virtual const double LEP2dsigmadcosBinE (const double s, const double cos, const double cosmin, const double cosmax) const
 
virtual const double LEP2dsigmadcosBinMu (const double s, const double cos, const double cosmin, const double cosmax) const
 
virtual const double LEP2dsigmadcosBinTau (const double s, const double cos, const double cosmin, const double cosmax) const
 
virtual const double LEP2dsigmadcosE (const double s, const double cos) const
 
virtual const double LEP2dsigmadcosMu (const double s, const double cos) const
 
virtual const double LEP2dsigmadcosTau (const double s, const double cos) const
 
virtual const double LEP2Rbottom (const double s) const
 
virtual const double LEP2Rcharm (const double s) const
 
virtual const double LEP2sigmaBottom (const double s) const
 
virtual const double LEP2sigmaCharm (const double s) const
 
virtual const double LEP2sigmaE (const double s) const
 
virtual const double LEP2sigmaHadron (const double s) const
 
virtual const double LEP2sigmaMu (const double s) const
 
virtual const double LEP2sigmaTau (const double s) const
 
const double MLL2eeff (const Particle f, const double s, const double t) const
 
const double MLR2eeff (const Particle f, const double s) const
 
const double MRL2eeff (const Particle f, const double s) const
 
const double MRR2eeff (const Particle f, const double s, const double t) const
 
virtual const double Mw () const
 The SM prediction for the \(W\)-boson mass in the on-shell scheme, \(M_{W,\mathrm{SM}}\). More...
 
const double Mw_tree () const
 The tree-level mass of the \(W\) boson, \(M_W^{\mathrm{tree}}\). More...
 
const double MwbarFromMw (const double Mw) const
 A method to convert the \(W\)-boson mass in the experimental/running-width scheme to that in the complex-pole/fixed-width scheme. More...
 
const double MwFromMwbar (const double Mwbar) const
 A method to convert the \(W\)-boson mass in the complex-pole/fixed-width scheme to that in the experimental/running-width scheme. More...
 
double Mzbar () const
 The \(Z\)-boson mass \(\overline{M}_Z\) in the complex-pole/fixed-width scheme. More...
 
virtual const double N_nu () const
 The number of neutrinos obtained indirectly from the measurements at the Z pole, \(N_{\nu}\). More...
 
virtual bool PostUpdate ()
 The post-update method for StandardModel. More...
 
virtual bool PreUpdate ()
 The pre-update method for StandardModel. More...
 
virtual const double Qwemoller (const double q2, const double y) const
 The computation of the electron's weak charge. More...
 
virtual const double Qwn () const
 The computation of the neutron weak charge: Qwn. More...
 
virtual const double Qwp () const
 The computation of the proton weak charge: Qwp. More...
 
virtual const double R0_f (const Particle f) const
 The ratio \(R_\ell^0=\Gamma(Z\to {\rm hadrons})/\Gamma(Z\to \ell^+ \ell^-)\). More...
 
virtual const double R_inv () const
 The ratio of the invisible and leptonic (electron) decay widths of the \(Z\) boson, \(R_{inv}\). More...
 
virtual const double rho_GammaW (const Particle fi, const Particle fj) const
 EW radiative corrections to the width of \(W \to f_i \bar{f}_j\), denoted as \(\rho^W_{ij}\). More...
 
virtual const gslpp::complex rhoZ_f (const Particle f) const
 The effective leptonic neutral-current coupling \(\rho_Z^l\) in the SM. More...
 
virtual const double Ruc () const
 
virtual const double RWc () const
 The ratio \(R_{W,c)=\Gamma(W\to c + X)/\Gamma(W\to had)\). More...
 
virtual const double RWlilj (const Particle li, const Particle lj) const
 The lepton universality ratio \(R_{W,l_i/l_j)=\Gamma(W\to l_i \nu_i)/\Gamma(W\to l_j \nu_j)\). More...
 
virtual const double RZlilj (const Particle li, const Particle lj) const
 The lepton universality ratio \(R_{Z,l_i/l_j)=\Gamma(Z\to l_i^+ l_i^-)/\Gamma(Z\to l_j^+ l_j^-)\). More...
 
const double s02 () const
 The square of the sine of the weak mixing angle \(s_0^2\) defined without weak radiative corrections. More...
 
void setCKM (const CKM &CKMMatrix)
 A set method to change the CKM matrix. More...
 
virtual bool setFlag (const std::string name, const bool value)
 A method to set a flag of StandardModel. More...
 
void setFlagCacheInStandardModel (bool FlagCacheInStandardModel)
 A set method to change the model flag CacheInStandardModel of StandardModel. More...
 
void setFlagNoApproximateGammaZ (bool FlagNoApproximateGammaZ)
 
bool setFlagSigmaForAFB (const bool flagSigmaForAFB_i)
 
bool setFlagSigmaForR (const bool flagSigmaForR_i)
 
virtual bool setFlagStr (const std::string name, const std::string value)
 A method to set a flag of StandardModel. More...
 
void setRequireCKM (bool requireCKM)
 A set method to change the value of requireCKM. More...
 
void setSMSuccess (bool success) const
 A set method to change the success status of the Standard Model update and matching. More...
 
void setYd (const gslpp::matrix< gslpp::complex > &Yd)
 A set method to set the Yukawa matrix of the down-type quarks, \(Y_d\). More...
 
void setYe (const gslpp::matrix< gslpp::complex > &Ye)
 A set method to set the Yukawa matrix of the charged leptons, \(Y_e\). More...
 
void setYu (const gslpp::matrix< gslpp::complex > &Yu)
 A set method to set the Yukawa matrix of the up-type quarks, \(Y_u\). More...
 
virtual const double sigma0_had () const
 The hadronic cross section for \(e^+e^- \to Z \to \mathrm{hadrons}\) at the \(Z\)-pole, \(\sigma_h^0\). More...
 
virtual const double SigmaeeHee (const double sqrt_s, const double Pe, const double Pp) const
 The \(\sigma(e^+ e^- \to e^+ e^- H)\) in the Standard Model. More...
 
virtual const double SigmaeeHvv (const double sqrt_s, const double Pe, const double Pp) const
 The \(\sigma(e^+ e^- \to \nu \bar{\nu} H)\) in the Standard Model. More...
 
virtual const double SigmaeeZH (const double sqrt_s, const double Pe, const double Pp) const
 The \(\sigma(e^+ e^- \to Z H)\) in the Standard Model. More...
 
virtual const double sin2thetaEff (const Particle f) const
 The effective weak mixing angle \(\sin^2\theta_{\rm eff}^{\,\ell}\) for \(Z\ell\bar{\ell}\) at the the \(Z\)-mass scale. More...
 
 StandardModel ()
 The default constructor. More...
 
const double sW2 () const
 
virtual const double sW2 (const double Mw_i) const
 The square of the sine of the weak mixing angle in the on-shell scheme, denoted as \(s_W^2\). More...
 
const double sW2_MSbar_Approx () const
 The (approximated formula for the) square of the sine of the weak mixing angle in the MSbar scheme, denoted as \(\hat{s}_{W}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022) More...
 
const double sW2_ND () const
 The square of the sine of the weak mixing angle in the MSbar-ND scheme (w/o decoupling $\alpha\ln(m_t/M_Z)$ terms), denoted as \(\hat{s}_{ND}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022) (eq. 10.13a/10.13b) More...
 
virtual const double TauLFU_gmuge () const
 The computation of the LFU ratio \(g_\mu/ g_e \). More...
 
virtual const double TauLFU_gtauge () const
 The computation of the LFU ratio \(g_\tau/ g_e \). More...
 
virtual const double TauLFU_gtaugmu () const
 The computation of the LFU ratio \(g_\tau/ g_\mu \). More...
 
virtual const double TauLFU_gtaugmuK () const
 The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_K \). More...
 
virtual const double TauLFU_gtaugmuPi () const
 The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_\pi \). More...
 
virtual const double ThetaLnuN () const
 The effective neutrino nucleon LH parameter: ThetaLnuN. More...
 
virtual const double ThetaRnuN () const
 The effective neutrino nucleon RH parameter: ThetaRnuN. More...
 
const double tovers2 (const double cosmin, const double cosmax) const
 
const double uovers2 (const double cosmin, const double cosmax) const
 
virtual bool Update (const std::map< std::string, double > &DPars)
 The update method for StandardModel. More...
 
const double v () const
 The Higgs vacuum expectation value. More...
 
virtual ~StandardModel ()
 The default destructor. More...
 
- Public Member Functions inherited from QCD
const double AboveTh (const double mu) const
 The active flavour threshold above the scale \(\mu\) as defined in QCD::Thresholds(). More...
 
void addParameters (std::vector< std::string > params_i)
 A method to add parameters that are specific to only one set of observables. More...
 
const double Als (const double mu, const int Nf_in, const orders order=FULLNLO) const
 Computes the running strong coupling \(\alpha_s(\mu)\) with \(N_f\) active flavours in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda(). More...
 
const double Als (const double mu, const orders order=FULLNLO, const bool Nf_thr=true) const
 
const double Als4 (const double mu) const
 The value of \(\alpha_s^{\mathrm{FULLNLO}}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\). More...
 
const double AlsByOrder (const double mu, const int Nf_in, const orders order=FULLNLO) const
 
const double AlsByOrder (const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
 
const double AlsOLD (const double mu, const orders order=FULLNLO) const
 Computes the running strong coupling \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda(). More...
 
const double AlsWithInit (const double mu, const double alsi, const double mu_i, const int nf, const orders order) const
 Computes the running strong coupling \(\alpha_s(\mu)\) from \(\alpha_s(\mu_i)\) in the \(\overline{\mathrm{MS}}\) scheme, where it is forbidden to across a flavour threshold in the RG running from \(\mu_i\) to \(\mu\). More...
 
const double AlsWithLambda (const double mu, const orders order) const
 Computes the running strong coupling \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme with the use of \(\Lambda_{\rm QCD}\). More...
 
const double BelowTh (const double mu) const
 The active flavour threshold below the scale \(\mu\) as defined in QCD::Thresholds(). More...
 
const double Beta0 (const double nf) const
 The \(\beta_0(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
const double Beta1 (const double nf) const
 The \(\beta_1(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
const double Beta2 (const double nf) const
 The \(\beta_2(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
const double Beta3 (const double nf) const
 The \(\beta_3(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
void CacheShift (double cache[][5], int n) const
 A member used to manage the caching for this class. More...
 
void CacheShift (int cache[][5], int n) const
 
const orders FullOrder (orders order) const
 Return the FULLORDER enum corresponding to order. More...
 
const double Gamma0 (const double nf) const
 The \(\gamma_0\) coefficient used to compute the running of a mass. More...
 
const double Gamma1 (const double nf) const
 The \(\gamma_1\) coefficient used to compute the running of a mass. More...
 
const double Gamma2 (const double nf) const
 The \(\gamma_2\) coefficient used to compute the running of a mass. More...
 
const double getAlsM () const
 A get method to access the value of \(\alpha_s(M_{\alpha_s})\). More...
 
const BParametergetBBd () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta b = 2\) process in the \(B_d\) meson system. More...
 
const BParametergetBBd_subleading () const
 For getting the subleading bag parameters \(R_2 - R_3\) in \(\Delta b = 2\) process in the \(B_d\) meson system. More...
 
const BParametergetBBs () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta b = 2\) process in the \(B_s\) meson system. More...
 
const BParametergetBBs_subleading () const
 For getting the subleading bag parameters \(R_2 - R_3\) in \(\Delta b = 2\) process in the \(B_s\) meson system. More...
 
const BParametergetBD () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta c = 2\) process in the \(D^0\) meson system. More...
 
const BParametergetBK () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta s = 2\) process in the \(K^0\) meson system. More...
 
const BParametergetBKd1 () const
 
const BParametergetBKd3 () const
 
const double getCF () const
 A get method to access the Casimir factor of QCD. More...
 
const double getMAls () const
 A get method to access the mass scale \(M_{\alpha_s}\) at which the strong coupling constant measurement is provided. More...
 
const MesongetMesons (const QCD::meson m) const
 A get method to access a meson as an object of the type Meson. More...
 
const double getMtpole () const
 A get method to access the pole mass of the top quark. More...
 
const double getMub () const
 A get method to access the threshold between five- and four-flavour theory in GeV. More...
 
const double getMuc () const
 A get method to access the threshold between four- and three-flavour theory in GeV. More...
 
const double getMut () const
 A get method to access the threshold between six- and five-flavour theory in GeV. More...
 
const double getNc () const
 A get method to access the number of colours \(N_c\). More...
 
const double getOptionalParameter (std::string name) const
 A method to get parameters that are specific to only one set of observables. More...
 
const ParticlegetQuarks (const QCD::quark q) const
 A get method to access a quark as an object of the type Particle. More...
 
std::vector< std::string > getUnknownParameters ()
 A method to get the vector of the parameters that have been specified in the configuration file but not being used. More...
 
void initializeBParameter (std::string name_i) const
 A method to initialize B Parameter and the corresponding meson. More...
 
void initializeMeson (QCD::meson meson_i) const
 A method to initialize a meson. More...
 
bool isQCDsuccess () const
 A getter for the QCDsuccess flag. More...
 
const double logLambda (const double nf, orders order) const
 Computes \(\ln\Lambda_\mathrm{QCD}\) with nf flavours in GeV. More...
 
const double Mbar2Mp (const double mbar, const quark q, const orders order=FULLNNLO) const
 Converts the \(\overline{\mathrm{MS}}\) mass \(m(m)\) to the pole mass. More...
 
const double Mofmu2Mbar (const double m, const double mu, const quark q) const
 Converts a quark running mass at an arbitrary scale to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\). More...
 
const double Mp2Mbar (const double mp, const quark q, orders order=FULLNNLO) const
 Converts a quark pole mass to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\). More...
 
const double Mrun (const double mu, const double m, const quark q, const orders order=FULLNNLO) const
 Computes a running quark mass \(m(\mu)\) from \(m(m)\). More...
 
const double Mrun (const double mu_f, const double mu_i, const double m, const quark q, const orders order=FULLNNLO) const
 Runs a quark mass from \(\mu_i\) to \(\mu_f\). More...
 
const double Mrun4 (const double mu_f, const double mu_i, const double m) const
 The running of a mass with the number of flavours \(n_f = 4\). More...
 
const double MS2DRqmass (const double MSbar) const
 Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme. More...
 
const double MS2DRqmass (const double MSscale, const double MSbar) const
 Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme. More...
 
const double Nf (const double mu) const
 The number of active flavour at scale \(\mu\). More...
 
const double NfThresholdCorrections (double mu, double M, double als, int nf, orders order) const
 Threshold corrections in matching \(\alpha_s(n_f+1)\) with \(\alpha_s(n_f)\) from eq. (34) of hep-ph/0512060. More...
 
const std::string orderToString (const orders order) const
 Converts an object of the enum type "orders" to the corresponding string. More...
 
 QCD ()
 Constructor. More...
 
void setComputemt (bool computemt)
 A set method to change the value of computemt. More...
 
void setMtpole (double mtpole_in)
 A method to set the pole mass of the top quark. More...
 
void setNc (double Nc)
 A set method to change the number of colours \(N_c\). More...
 
void setOptionalParameter (std::string name, double value)
 A method to set the parameter value for the parameters that are specific to only one set of observables. More...
 
void setQuarkMass (const quark q, const double mass)
 A set method to change the mass of a quark. More...
 
const double Thresholds (const int i) const
 For accessing the active flavour threshold scales. More...
 
- Public Member Functions inherited from Model
void addMissingModelParameter (const std::string &missingParameterName)
 
std::vector< std::string > getmissingModelParameters ()
 
unsigned int getMissingModelParametersCount ()
 
std::string getModelName () const
 A method to fetch the name of the model. More...
 
const double & getModelParam (std::string name) const
 
bool isModelFWC_DF2 () const
 
bool isModelGeneralTHDM () const
 
bool isModelGeorgiMachacek () const
 
bool IsModelInitialized () const
 A method to check if the model is initialized. More...
 
bool isModelLinearized () const
 
bool isModelNPquadratic () const
 
bool isModelParam (std::string name) const
 
bool isModelSUSY () const
 
bool isModelTHDM () const
 
bool isModelTHDMW () const
 
bool IsUpdateError () const
 A method to check if there was any error in the model update process. More...
 
 Model ()
 The default constructor. More...
 
void raiseMissingModelParameterCount ()
 
void setModelFWC_DF2 ()
 
void setModelGeneralTHDM ()
 
void setModelGeorgiMachacek ()
 
void setModelInitialized (bool ModelInitialized)
 A set method to fix the failure or success of the initialization of the model. More...
 
void setModelLinearized (bool linearized=true)
 
void setModelName (const std::string name)
 A method to set the name of the model. More...
 
void setModelNPquadratic (bool NPquadratic=true)
 
void setModelSUSY ()
 
void setModelTHDM ()
 
void setModelTHDMW ()
 
void setSliced (bool Sliced)
 
void setUpdateError (bool UpdateError)
 A set method to fix the update status as success or failure. More...
 
virtual ~Model ()
 The default destructor. More...
 

Static Public Attributes

static const double GeVminus2_to_nb = 389379.338
 
static const double Mw_error = 0.00001
 The target accuracy of the iterative calculation of the \(W\)-boson mass in units of GeV. More...
 
static const int NSMvars = 28
 The number of the model parameters in StandardModel. More...
 
static const int NumSMParamsForEWPO = 35
 The number of the SM parameters that are relevant to the EW precision observables. More...
 
static std::string SMvars [NSMvars]
 A string array containing the labels of the model parameters in StandardModel. More...
 
- Static Public Attributes inherited from QCD
static const int NQCDvars = 11
 The number of model parameters in QCD. More...
 
static std::string QCDvars [NQCDvars]
 An array containing the labels under which all QCD parameters are stored in a vector of ModelParameter via InputParser::ReadParameters(). More...
 

Protected Member Functions

const double AFB_NoISR_l (const QCD::lepton l_flavor, const double s) const
 
const double AFB_NoISR_q (const QCD::quark q_flavor, const double s) const
 
bool checkEWPOscheme (const std::string scheme) const
 A method to check if a given scheme name in string form is valid. More...
 
virtual void computeCKM ()
 The method to compute the CKM matrix. More...
 
virtual void computeYukawas ()
 The method to compute the Yukawas matrix. More...
 
double Delta_EWQCD (const QCD::quark q) const
 The non-factorizable EW-QCD corrections to the partial widths for \(Z\to q\bar{q}\), denoted as \(\Delta_{\mathrm{EW/QCD}}\). More...
 
const double getIntegrand_AFBnumeratorWithISR_bottom133 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom167 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom207 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm133 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm167 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm207 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu130 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu136 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu161 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu207 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau130 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau136 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau161 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau207 (double x) const
 
const double getIntegrand_dsigmaBox_bottom130 (double x) const
 
const double getIntegrand_dsigmaBox_bottom133 (double x) const
 
const double getIntegrand_dsigmaBox_bottom136 (double x) const
 
const double getIntegrand_dsigmaBox_bottom161 (double x) const
 
const double getIntegrand_dsigmaBox_bottom167 (double x) const
 
const double getIntegrand_dsigmaBox_bottom172 (double x) const
 
const double getIntegrand_dsigmaBox_bottom183 (double x) const
 
const double getIntegrand_dsigmaBox_bottom189 (double x) const
 
const double getIntegrand_dsigmaBox_bottom192 (double x) const
 
const double getIntegrand_dsigmaBox_bottom196 (double x) const
 
const double getIntegrand_dsigmaBox_bottom200 (double x) const
 
const double getIntegrand_dsigmaBox_bottom202 (double x) const
 
const double getIntegrand_dsigmaBox_bottom205 (double x) const
 
const double getIntegrand_dsigmaBox_bottom207 (double x) const
 
const double getIntegrand_dsigmaBox_charm130 (double x) const
 
const double getIntegrand_dsigmaBox_charm133 (double x) const
 
const double getIntegrand_dsigmaBox_charm136 (double x) const
 
const double getIntegrand_dsigmaBox_charm161 (double x) const
 
const double getIntegrand_dsigmaBox_charm167 (double x) const
 
const double getIntegrand_dsigmaBox_charm172 (double x) const
 
const double getIntegrand_dsigmaBox_charm183 (double x) const
 
const double getIntegrand_dsigmaBox_charm189 (double x) const
 
const double getIntegrand_dsigmaBox_charm192 (double x) const
 
const double getIntegrand_dsigmaBox_charm196 (double x) const
 
const double getIntegrand_dsigmaBox_charm200 (double x) const
 
const double getIntegrand_dsigmaBox_charm202 (double x) const
 
const double getIntegrand_dsigmaBox_charm205 (double x) const
 
const double getIntegrand_dsigmaBox_charm207 (double x) const
 
const double getIntegrand_dsigmaBox_down130 (double x) const
 
const double getIntegrand_dsigmaBox_down133 (double x) const
 
const double getIntegrand_dsigmaBox_down136 (double x) const
 
const double getIntegrand_dsigmaBox_down161 (double x) const
 
const double getIntegrand_dsigmaBox_down167 (double x) const
 
const double getIntegrand_dsigmaBox_down172 (double x) const
 
const double getIntegrand_dsigmaBox_down183 (double x) const
 
const double getIntegrand_dsigmaBox_down189 (double x) const
 
const double getIntegrand_dsigmaBox_down192 (double x) const
 
const double getIntegrand_dsigmaBox_down196 (double x) const
 
const double getIntegrand_dsigmaBox_down200 (double x) const
 
const double getIntegrand_dsigmaBox_down202 (double x) const
 
const double getIntegrand_dsigmaBox_down205 (double x) const
 
const double getIntegrand_dsigmaBox_down207 (double x) const
 
const double getIntegrand_dsigmaBox_mu130 (double x) const
 
const double getIntegrand_dsigmaBox_mu133 (double x) const
 
const double getIntegrand_dsigmaBox_mu136 (double x) const
 
const double getIntegrand_dsigmaBox_mu161 (double x) const
 
const double getIntegrand_dsigmaBox_mu167 (double x) const
 
const double getIntegrand_dsigmaBox_mu172 (double x) const
 
const double getIntegrand_dsigmaBox_mu183 (double x) const
 
const double getIntegrand_dsigmaBox_mu189 (double x) const
 
const double getIntegrand_dsigmaBox_mu192 (double x) const
 
const double getIntegrand_dsigmaBox_mu196 (double x) const
 
const double getIntegrand_dsigmaBox_mu200 (double x) const
 
const double getIntegrand_dsigmaBox_mu202 (double x) const
 
const double getIntegrand_dsigmaBox_mu205 (double x) const
 
const double getIntegrand_dsigmaBox_mu207 (double x) const
 
const double getIntegrand_dsigmaBox_strange130 (double x) const
 
const double getIntegrand_dsigmaBox_strange133 (double x) const
 
const double getIntegrand_dsigmaBox_strange136 (double x) const
 
const double getIntegrand_dsigmaBox_strange161 (double x) const
 
const double getIntegrand_dsigmaBox_strange167 (double x) const
 
const double getIntegrand_dsigmaBox_strange172 (double x) const
 
const double getIntegrand_dsigmaBox_strange183 (double x) const
 
const double getIntegrand_dsigmaBox_strange189 (double x) const
 
const double getIntegrand_dsigmaBox_strange192 (double x) const
 
const double getIntegrand_dsigmaBox_strange196 (double x) const
 
const double getIntegrand_dsigmaBox_strange200 (double x) const
 
const double getIntegrand_dsigmaBox_strange202 (double x) const
 
const double getIntegrand_dsigmaBox_strange205 (double x) const
 
const double getIntegrand_dsigmaBox_strange207 (double x) const
 
const double getIntegrand_dsigmaBox_tau130 (double x) const
 
const double getIntegrand_dsigmaBox_tau133 (double x) const
 
const double getIntegrand_dsigmaBox_tau136 (double x) const
 
const double getIntegrand_dsigmaBox_tau161 (double x) const
 
const double getIntegrand_dsigmaBox_tau167 (double x) const
 
const double getIntegrand_dsigmaBox_tau172 (double x) const
 
const double getIntegrand_dsigmaBox_tau183 (double x) const
 
const double getIntegrand_dsigmaBox_tau189 (double x) const
 
const double getIntegrand_dsigmaBox_tau192 (double x) const
 
const double getIntegrand_dsigmaBox_tau196 (double x) const
 
const double getIntegrand_dsigmaBox_tau200 (double x) const
 
const double getIntegrand_dsigmaBox_tau202 (double x) const
 
const double getIntegrand_dsigmaBox_tau205 (double x) const
 
const double getIntegrand_dsigmaBox_tau207 (double x) const
 
const double getIntegrand_dsigmaBox_up130 (double x) const
 
const double getIntegrand_dsigmaBox_up133 (double x) const
 
const double getIntegrand_dsigmaBox_up136 (double x) const
 
const double getIntegrand_dsigmaBox_up161 (double x) const
 
const double getIntegrand_dsigmaBox_up167 (double x) const
 
const double getIntegrand_dsigmaBox_up172 (double x) const
 
const double getIntegrand_dsigmaBox_up183 (double x) const
 
const double getIntegrand_dsigmaBox_up189 (double x) const
 
const double getIntegrand_dsigmaBox_up192 (double x) const
 
const double getIntegrand_dsigmaBox_up196 (double x) const
 
const double getIntegrand_dsigmaBox_up200 (double x) const
 
const double getIntegrand_dsigmaBox_up202 (double x) const
 
const double getIntegrand_dsigmaBox_up205 (double x) const
 
const double getIntegrand_dsigmaBox_up207 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom130 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom133 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom136 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom161 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom167 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom172 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom183 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom189 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom192 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom196 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom200 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom202 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom205 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom207 (double x) const
 
const double getIntegrand_sigmaWithISR_charm130 (double x) const
 
const double getIntegrand_sigmaWithISR_charm133 (double x) const
 
const double getIntegrand_sigmaWithISR_charm136 (double x) const
 
const double getIntegrand_sigmaWithISR_charm161 (double x) const
 
const double getIntegrand_sigmaWithISR_charm167 (double x) const
 
const double getIntegrand_sigmaWithISR_charm172 (double x) const
 
const double getIntegrand_sigmaWithISR_charm183 (double x) const
 
const double getIntegrand_sigmaWithISR_charm189 (double x) const
 
const double getIntegrand_sigmaWithISR_charm192 (double x) const
 
const double getIntegrand_sigmaWithISR_charm196 (double x) const
 
const double getIntegrand_sigmaWithISR_charm200 (double x) const
 
const double getIntegrand_sigmaWithISR_charm202 (double x) const
 
const double getIntegrand_sigmaWithISR_charm205 (double x) const
 
const double getIntegrand_sigmaWithISR_charm207 (double x) const
 
const double getIntegrand_sigmaWithISR_down130 (double x) const
 
const double getIntegrand_sigmaWithISR_down133 (double x) const
 
const double getIntegrand_sigmaWithISR_down136 (double x) const
 
const double getIntegrand_sigmaWithISR_down161 (double x) const
 
const double getIntegrand_sigmaWithISR_down167 (double x) const
 
const double getIntegrand_sigmaWithISR_down172 (double x) const
 
const double getIntegrand_sigmaWithISR_down183 (double x) const
 
const double getIntegrand_sigmaWithISR_down189 (double x) const
 
const double getIntegrand_sigmaWithISR_down192 (double x) const
 
const double getIntegrand_sigmaWithISR_down196 (double x) const
 
const double getIntegrand_sigmaWithISR_down200 (double x) const
 
const double getIntegrand_sigmaWithISR_down202 (double x) const
 
const double getIntegrand_sigmaWithISR_down205 (double x) const
 
const double getIntegrand_sigmaWithISR_down207 (double x) const
 
const double getIntegrand_sigmaWithISR_mu130 (double x) const
 
const double getIntegrand_sigmaWithISR_mu136 (double x) const
 
const double getIntegrand_sigmaWithISR_mu161 (double x) const
 
const double getIntegrand_sigmaWithISR_mu172 (double x) const
 
const double getIntegrand_sigmaWithISR_mu183 (double x) const
 
const double getIntegrand_sigmaWithISR_mu189 (double x) const
 
const double getIntegrand_sigmaWithISR_mu192 (double x) const
 
const double getIntegrand_sigmaWithISR_mu196 (double x) const
 
const double getIntegrand_sigmaWithISR_mu200 (double x) const
 
const double getIntegrand_sigmaWithISR_mu202 (double x) const
 
const double getIntegrand_sigmaWithISR_mu205 (double x) const
 
const double getIntegrand_sigmaWithISR_mu207 (double x) const
 
const double getIntegrand_sigmaWithISR_strange130 (double x) const
 
const double getIntegrand_sigmaWithISR_strange133 (double x) const
 
const double getIntegrand_sigmaWithISR_strange136 (double x) const
 
const double getIntegrand_sigmaWithISR_strange161 (double x) const
 
const double getIntegrand_sigmaWithISR_strange167 (double x) const
 
const double getIntegrand_sigmaWithISR_strange172 (double x) const
 
const double getIntegrand_sigmaWithISR_strange183 (double x) const
 
const double getIntegrand_sigmaWithISR_strange189 (double x) const
 
const double getIntegrand_sigmaWithISR_strange192 (double x) const
 
const double getIntegrand_sigmaWithISR_strange196 (double x) const
 
const double getIntegrand_sigmaWithISR_strange200 (double x) const
 
const double getIntegrand_sigmaWithISR_strange202 (double x) const
 
const double getIntegrand_sigmaWithISR_strange205 (double x) const
 
const double getIntegrand_sigmaWithISR_strange207 (double x) const
 
const double getIntegrand_sigmaWithISR_tau130 (double x) const
 
const double getIntegrand_sigmaWithISR_tau136 (double x) const
 
const double getIntegrand_sigmaWithISR_tau161 (double x) const
 
const double getIntegrand_sigmaWithISR_tau172 (double x) const
 
const double getIntegrand_sigmaWithISR_tau183 (double x) const
 
const double getIntegrand_sigmaWithISR_tau189 (double x) const
 
const double getIntegrand_sigmaWithISR_tau192 (double x) const
 
const double getIntegrand_sigmaWithISR_tau196 (double x) const
 
const double getIntegrand_sigmaWithISR_tau200 (double x) const
 
const double getIntegrand_sigmaWithISR_tau202 (double x) const
 
const double getIntegrand_sigmaWithISR_tau205 (double x) const
 
const double getIntegrand_sigmaWithISR_tau207 (double x) const
 
const double getIntegrand_sigmaWithISR_up130 (double x) const
 
const double getIntegrand_sigmaWithISR_up133 (double x) const
 
const double getIntegrand_sigmaWithISR_up136 (double x) const
 
const double getIntegrand_sigmaWithISR_up161 (double x) const
 
const double getIntegrand_sigmaWithISR_up167 (double x) const
 
const double getIntegrand_sigmaWithISR_up172 (double x) const
 
const double getIntegrand_sigmaWithISR_up183 (double x) const
 
const double getIntegrand_sigmaWithISR_up189 (double x) const
 
const double getIntegrand_sigmaWithISR_up192 (double x) const
 
const double getIntegrand_sigmaWithISR_up196 (double x) const
 
const double getIntegrand_sigmaWithISR_up200 (double x) const
 
const double getIntegrand_sigmaWithISR_up202 (double x) const
 
const double getIntegrand_sigmaWithISR_up205 (double x) const
 
const double getIntegrand_sigmaWithISR_up207 (double x) const
 
const double Integrand_AFBnumeratorWithISR_l (double x, const QCD::lepton l_flavor, const double s) const
 
const double Integrand_AFBnumeratorWithISR_q (double x, const QCD::quark q_flavor, const double s) const
 
const double Integrand_dsigmaBox_l (double cosTheta, const QCD::lepton l_flavor, const double s) const
 
const double Integrand_dsigmaBox_q (double cosTheta, const QCD::quark q_flavor, const double s) const
 
const double Integrand_sigmaWithISR_l (double x, const QCD::lepton l_flavor, const double s) const
 
const double Integrand_sigmaWithISR_q (double x, const QCD::quark q_flavor, const double s) const
 
double m_q (const QCD::quark q, const double mu, const orders order=FULLNLO) const
 
double RAq (const QCD::quark q) const
 The radiator factor associated with the final-state QED and QCD corrections to the the axial-vector-current interactions, \(R_A^q(M_Z^2)\). More...
 
double resumKappaZ (const double DeltaRho[orders_EW_size], const double deltaKappa_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
 A method to compute the real part of the effetvive coupling \(\kappa_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\). More...
 
double resumMw (const double Mw_i, const double DeltaRho[orders_EW_size], const double DeltaR_rem[orders_EW_size]) const
 A method to compute the \(W\)-boson mass from \(\Delta\rho\) and \(\Delta r_{\mathrm{rem}}\). More...
 
double resumRhoZ (const double DeltaRho[orders_EW_size], const double deltaRho_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
 A method to compute the real part of the effective coupling \(\rho_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\). More...
 
double RVh () const
 The singlet vector corrections to the hadronic \(Z\)-boson width, denoted as \(R_V^h\). More...
 
double RVq (const QCD::quark q) const
 The radiator factor associated with the final-state QED and QCD corrections to the the vector-current interactions, \(R_V^q(M_Z^2)\). More...
 
double SchemeToDouble (const std::string scheme) const
 A method to convert a given scheme name in string form into a floating-point number with double precision. More...
 
virtual void setParameter (const std::string name, const double &value)
 A method to set the value of a parameter of StandardModel. More...
 
const double sigma_NoISR_l (const QCD::lepton l_flavor, const double s) const
 
const double sigma_NoISR_q (const QCD::quark q_flavor, const double s) const
 
double taub () const
 Top-mass corrections to the \(Zb\bar{b}\) vertex, denoted by \(\tau_b\). More...
 
- Protected Member Functions inherited from QCD
const double MassOfNf (int nf) const
 The Mbar mass of the heaviest quark in the theory with Nf active flavour. More...
 

Protected Attributes

double A
 The CKM parameter \(A\) in the Wolfenstein parameterization. More...
 
double ale
 The fine-structure constant \(\alpha\). More...
 
double alpha21
 
double alpha31
 
double AlsMz
 The strong coupling constant at the Z-boson mass, \(\alpha_s(M_Z)\). More...
 
bool bSigmaForAFB
 
bool bSigmaForR
 
double dAl5hMz
 The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\). (Non-input parameter) More...
 
double dAle5Mz
 The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\), used as input for FlagMWinput = FALSE. More...
 
double delGammaWlv
 The theoretical uncertainty in \(\Gamma_W_{l\nu}\), denoted as \(\delta\,\Gamma_W_{l\nu}\). More...
 
double delGammaWqq
 The theoretical uncertainty in \(\Gamma_W_{qq}\), denoted as \(\delta\,\Gamma_W_{qq}\). More...
 
double delGammaZ
 The theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\), in GeV. More...
 
double delMw
 The theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\), in GeV. More...
 
double delR0b
 The theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\). More...
 
double delR0c
 The theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\). More...
 
double delR0l
 The theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\). More...
 
double delsigma0H
 The theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\) in nb. More...
 
double delSin2th_b
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\). More...
 
double delSin2th_l
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\). More...
 
double delSin2th_q
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\). More...
 
double delta
 
double etab
 The CKM parameter \(\bar{\eta}\) in the Wolfenstein parameterization. More...
 
bool flag_order [orders_EW_size]
 An array of internal flags controlling the inclusions of higher-order corrections. More...
 
bool FlagFixMuwMut
 A boolean for the model flag FixMuwMut. More...
 
bool flagLEP2 [NUMofLEP2RCs]
 
double gamma
 \(\gamma \) used as an input for FlagWolfenstein = FALSE More...
 
double GF
 The Fermi constant \(G_\mu\) in \({\rm GeV}^{-2}\). More...
 
double lambda
 The CKM parameter \(\lambda\) in the Wolfenstein parameterization. More...
 
Particle leptons [6]
 An array of Particle objects for the leptons. More...
 
double mHl
 The Higgs mass \(m_h\) in GeV. More...
 
double muw
 A matching scale \(\mu_W\) around the weak scale in GeV. More...
 
double Mw_inp
 The mass of the \(W\) boson in GeV used as input for FlagMWinput = TRUE. More...
 
CKM myCKM
 An object of type CKM. More...
 
PMNS myPMNS
 
double Mz
 The mass of the \(Z\) boson in GeV. More...
 
bool requireCKM
 An internal flag to control whether the CKM matrix has to be recomputed. More...
 
bool requireYe
 An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed. More...
 
bool requireYn
 An internal flag to control whether the neutrino Yukawa matrix has to be recomputed. More...
 
double rhob
 The CKM parameter \(\bar{\rho}\) in the Wolfenstein parameterization. More...
 
double s12
 
double s13
 
double s23
 
Flavour SMFlavour
 An object of type Flavour. More...
 
Matching< StandardModelMatching, StandardModelSMM
 An object of type Matching. More...
 
double Vcb
 \(\vert V_{cb} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
double Vub
 \(\vert V_{ub} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
double Vud
 \(\vert V_{ud} \vert \) used as an input for FlagWolfenstein = FALSE and FlagUseVud = TRUE More...
 
double Vus
 \(\vert V_{us} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
gslpp::matrix< gslpp::complex > Yd
 The Yukawa matrix of the down-type quarks. More...
 
gslpp::matrix< gslpp::complex > Ye
 The Yukawa matrix of the charged leptons. More...
 
gslpp::matrix< gslpp::complex > Yn
 The Yukawa matrix of the neutrinos. More...
 
gslpp::matrix< gslpp::complex > Yu
 The Yukawa matrix of the up-type quarks. More...
 
- Protected Attributes inherited from QCD
double AlsM
 The strong coupling constant at the mass scale MAls, \(\alpha_s(M_{\alpha_s})\). More...
 
double CA
 
double CF
 
bool computemt
 Switch for computing the \(\overline{\mathrm{MS}}\) mass of the top quark. More...
 
double dAdA_NA
 
double dFdA_NA
 
double dFdF_NA
 
bool FlagMpole2MbarNumeric
 A flag to determine whether the pole mass to \(\over \mathrm{MS}\) mass conversion is done numerically. More...
 
bool FlagMtPole
 A flag to determine whether the pole mass of the top quark is used as input. More...
 
double MAls
 The mass scale in GeV at which the strong coupling measurement is provided. More...
 
double mtpole
 The pole mass of the top quark. More...
 
double mub
 The threshold between five- and four-flavour theory in GeV. More...
 
double muc
 The threshold between four- and three-flavour theory in GeV. More...
 
double mut
 The threshold between six- and five-flavour theory in GeV. More...
 
double NA
 
double Nc
 The number of colours. More...
 
bool QCDsuccess =true
 
Particle quarks [6]
 The vector of all SM quarks. More...
 
bool requireYd
 Switch for generating the Yukawa couplings to the down-type quarks. More...
 
bool requireYu
 Switch for generating the Yukawa couplings to the up-type quarks. More...
 
double TF
 
- Protected Attributes inherited from Model
bool isSliced = false
 A boolean set to true if the current istance is a slice of an extended object. More...
 
std::map< std::string, std::reference_wrapper< const double > > ModelParamMap
 
bool UpdateError = false
 A boolean set to false if update is successful. More...
 

Private Member Functions

const double AleWithInit (double mu, double alsi, double mu_i, orders order) const
 
const double AlsE (double mu, orders order, bool Nf_thr) const
 
const double AlsEByOrder (double mu, orders order, bool Nf_thr) const
 
const double AlsEWithInit (double mu, double alsi, double mu_i, const int nf_i, orders order) const
 

Private Attributes

double ale_cache [10][CacheSize]
 Cache for \(\alpha_e\). More...
 
double als_cache [11][CacheSize]
 Cache for \(\alpha_s\). More...
 
double average
 
double DeltaAlpha_cache
 A cache of the value of \(\Delta\alpha(M_Z^2)\). More...
 
double DeltaAlphaLepton_cache
 A cache of the value of \(\Delta\alpha_{\mathrm{lept}}(M_Z^2)\). More...
 
double error
 
gsl_function f_GSL
 
bool FlagCacheInStandardModel
 A flag for caching (true by default). More...
 
std::string FlagKappaZ
 A string for the model flag KappaZ. More...
 
std::string FlagMw
 A string for the model flag Mw. More...
 
bool FlagMWinput
 A boolean for the model flag MWinput.
More...
 
bool FlagNoApproximateGammaZ
 A boolean for the model flag NoApproximateGammaZ. More...
 
std::string FlagRhoZ
 A string for the model flag RhoZ. More...
 
bool FlagSMAux
 A boolean for the model flag SMAux. More...
 
bool FlagUseVud
 A boolean for the model flag UseVud. More...
 
bool FlagWithoutNonUniversalVC
 A boolean for the model flag WithoutNonUniversalVC. More...
 
bool FlagWolfenstein
 A boolean for the model flag Wolfenstein. More...
 
double GammaW_cache
 A cache of the value of \(\Gamma_W\). More...
 
int iterationNo
 
gslpp::complex kappaZ_f_cache [12]
 A cache of the value of \(\kappa_Z^l\). More...
 
double Mw_cache
 A cache of the value of \(M_W\). More...
 
EWSMApproximateFormulaemyApproximateFormulae
 A pointer to an object of type EWSMApproximateFormulae. More...
 
EWSMcachemyEWSMcache
 A pointer to an object of type EWSMcache. More...
 
LeptonFlavourmyLeptonFlavour
 A pointer to an object of the type LeptonFlavour. More...
 
EWSMOneLoopEWmyOneLoopEW
 A pointer to an object of type EWSMOneLoopEW. More...
 
EWSMThreeLoopEWmyThreeLoopEW
 A pointer to an object of type EWSMThreeLoopEW. More...
 
EWSMThreeLoopEW2QCDmyThreeLoopEW2QCD
 A pointer to an object of type EWSMThreeLoopEW2QCD. More...
 
EWSMThreeLoopQCDmyThreeLoopQCD
 A pointer to an object of type EWSMThreeLoopQCD. More...
 
EWSMTwoFermionsLEP2myTwoFermionsLEP2
 A pointer to an object of type EWSMTwoFermionsLEP2. More...
 
EWSMTwoLoopEWmyTwoLoopEW
 A pointer to an object of type EWSMTwoLoopEW. More...
 
EWSMTwoLoopQCDmyTwoLoopQCD
 A pointer to an object of type EWSMTwoLoopQCD. More...
 
orders realorder
 
gslpp::complex rhoZ_f_cache [12]
 A cache of the value of \(\rho_Z^l\). More...
 
double SMparamsForEWPO_cache [NumSMParamsForEWPO]
 
double SMresult_cache
 
bool SMSuccess
 A boolean for the success of the Standard Model update and matching. More...
 
bool useDeltaAlpha_cache
 
bool useDeltaAlphaLepton_cache
 
bool useGammaW_cache
 
bool useKappaZ_f_cache [12]
 
bool useMw_cache
 
bool useRhoZ_f_cache [12]
 
gsl_integration_workspace * w_GSL1
 

Static Private Attributes

static const int CacheSize = 5
 Defines the depth of the cache. More...
 

Member Enumeration Documentation

◆ LEP2RCs

Enumerator
Weak 
WeakBox 
ISR 
QEDFSR 
QCDFSR 
NUMofLEP2RCs 

Definition at line 526 of file StandardModel.h.

◆ orders_EW

An enumerated type representing perturbative orders of radiative corrections to EW precision observables.

Enumerator
EW1 

One-loop of \(\mathcal{O}(\alpha)\).

EW1QCD1 

Two-loop of \(\mathcal{O}(\alpha\alpha_s)\).

EW1QCD2 

Three-loop of \(\mathcal{O}(\alpha\alpha_s^2)\).

EW2 

Two-loop of \(\mathcal{O}(\alpha^2)\).

EW2QCD1 

Three-loop of \(\mathcal{O}(\alpha^2\alpha_s)\).

EW3 

Three-loop of \(\mathcal{O}(\alpha^3)\).

orders_EW_size 

The size of this enum.

Definition at line 539 of file StandardModel.h.

539 {
540 EW1 = 0,
541 EW1QCD1,
542 EW1QCD2,
543 EW2,
544 EW2QCD1,
545 EW3,
547 };
@ EW1
One-loop of .
@ EW2QCD1
Three-loop of .
@ EW2
Two-loop of .
@ orders_EW_size
The size of this enum.
@ EW3
Three-loop of .
@ EW1QCD1
Two-loop of .
@ EW1QCD2
Three-loop of .

Constructor & Destructor Documentation

◆ StandardModel()

StandardModel::StandardModel ( )

The default constructor.

Definition at line 41 of file StandardModel/src/StandardModel.cpp.

42: QCD(), Yu(3, 3, 0.), Yd(3, 3, 0.), Yn(3, 3, 0.),
43SMM(*this), SMFlavour(*this), Ye(3, 3, 0.)
44{
45 setModelName("StandardModel");
46 requireCKM = false;
47 requireYe = false;
48 requireYn = false;
49
52 FlagMw = "APPROXIMATEFORMULA";
53 FlagRhoZ = "NORESUM";
54 FlagKappaZ = "APPROXIMATEFORMULA";
55 FlagWolfenstein = true;
56 FlagUseVud = false;
57 FlagFixMuwMut = false;
58
59 FlagMWinput = false;
60
61 FlagSMAux = false;
62
63 /* Internal flags for EWPO (for debugging) */
64 flag_order[EW1] = true;
65 flag_order[EW1QCD1] = true;
66 flag_order[EW1QCD2] = true;
67 flag_order[EW2] = true;
68 flag_order[EW2QCD1] = true;
69 flag_order[EW3] = true;
70
71 //Flags for LEP2 observables
72 flagLEP2[Weak] = true;
73 flagLEP2[WeakBox] = true;
74 flagLEP2[ISR] = true;
75 flagLEP2[QEDFSR] = true;
76 flagLEP2[QCDFSR] = true;
77
78 bSigmaForAFB = false;
79 bSigmaForR = false;
80
81 // Caches for EWPO
82 FlagCacheInStandardModel = true; // use caches in the current class
84 useDeltaAlpha_cache = false;
85 useMw_cache = false;
86 useGammaW_cache = false;
88 DeltaAlpha_cache = 0.0;
89 Mw_cache = 0.0;
90 GammaW_cache = 0.0;
91 for (int i = 0; i < 12; ++i) {
92 useRhoZ_f_cache[i] = false;
93 useKappaZ_f_cache[i] = false;
94 rhoZ_f_cache[i] = gslpp::complex(0.0, 0.0, false);
95 kappaZ_f_cache[i] = gslpp::complex(0.0, 0.0, false);
96 }
97
98 myEWSMcache = NULL;
99 myOneLoopEW = NULL;
100 myTwoLoopQCD = NULL;
101 myThreeLoopQCD = NULL;
102 myTwoLoopEW = NULL;
103 myThreeLoopEW2QCD = NULL;
104 myThreeLoopEW = NULL;
106 /* BEGIN: REMOVE FROM THE PACKAGE */
107 myTwoFermionsLEP2 = NULL;
108 /* END: REMOVE FROM THE PACKAGE */
109
110 // Particle(std::string name, double mass, double mass_scale = 0., double width = 0., double charge = 0.,double isospin = 0.);
111 leptons[NEUTRINO_1] = Particle("NEUTRINO_1", 0., 0., 0., 0., .5);
112 leptons[NEUTRINO_2] = Particle("NEUTRINO_2", 0., 0., 0., 0., .5);
113 leptons[NEUTRINO_3] = Particle("NEUTRINO_3", 0., 0., 0., 0., .5);
114 leptons[ELECTRON] = Particle("ELECTRON", 0., 0., 0., -1., -.5);
115 leptons[MU] = Particle("MU", 0., 0., 0., -1., -.5);
116 leptons[TAU] = Particle("TAU", 0., 0., 0., -1., -.5);
117
118 ModelParamMap.insert(std::make_pair("Mz", std::cref(Mz)));
119 ModelParamMap.insert(std::make_pair("AlsMz", std::cref(AlsMz)));
120 ModelParamMap.insert(std::make_pair("GF", std::cref(GF)));
121 ModelParamMap.insert(std::make_pair("ale", std::cref(ale)));
122 ModelParamMap.insert(std::make_pair("dAle5Mz", std::cref(dAle5Mz)));
123// ModelParamMap.insert(std::make_pair("Mw_inp", std::cref(Mw_inp)));
124 ModelParamMap.insert(std::make_pair("mHl", std::cref(mHl)));
125 ModelParamMap.insert(std::make_pair("delMw", std::cref(delMw)));
126 ModelParamMap.insert(std::make_pair("delSin2th_l", std::cref(delSin2th_l)));
127 ModelParamMap.insert(std::make_pair("delSin2th_q", std::cref(delSin2th_q)));
128 ModelParamMap.insert(std::make_pair("delSin2th_b", std::cref(delSin2th_b)));
129 ModelParamMap.insert(std::make_pair("delGammaZ", std::cref(delGammaZ)));
130 ModelParamMap.insert(std::make_pair("delsigma0H", std::cref(delsigma0H)));
131 ModelParamMap.insert(std::make_pair("delR0l", std::cref(delR0l)));
132 ModelParamMap.insert(std::make_pair("delR0c", std::cref(delR0c)));
133 ModelParamMap.insert(std::make_pair("delR0b", std::cref(delR0b)));
134 ModelParamMap.insert(std::make_pair("delGammaWlv", std::cref(delGammaWlv)));
135 ModelParamMap.insert(std::make_pair("delGammaWqq", std::cref(delGammaWqq)));
136 ModelParamMap.insert(std::make_pair("mneutrino_1", std::cref(leptons[NEUTRINO_1].getMass())));
137 ModelParamMap.insert(std::make_pair("mneutrino_2", std::cref(leptons[NEUTRINO_2].getMass())));
138 ModelParamMap.insert(std::make_pair("mneutrino_3", std::cref(leptons[NEUTRINO_3].getMass())));
139 ModelParamMap.insert(std::make_pair("melectron", std::cref(leptons[ELECTRON].getMass())));
140 ModelParamMap.insert(std::make_pair("mmu", std::cref(leptons[MU].getMass())));
141 ModelParamMap.insert(std::make_pair("mtau", std::cref(leptons[TAU].getMass())));
142 ModelParamMap.insert(std::make_pair("lambda", std::cref(lambda)));
143 ModelParamMap.insert(std::make_pair("A", std::cref(A)));
144 ModelParamMap.insert(std::make_pair("rhob", std::cref(rhob)));
145 ModelParamMap.insert(std::make_pair("etab", std::cref(etab)));
146 ModelParamMap.insert(std::make_pair("muw", std::cref(muw)));
147
148 iterationNo = 0;
149 realorder = LO;
150
151 w_GSL1 = gsl_integration_workspace_alloc (200);
152}
@ LO
Definition: OrderScheme.h:34
std::map< std::string, std::reference_wrapper< const double > > ModelParamMap
Definition: Model.h:280
void setModelName(const std::string name)
A method to set the name of the model.
Definition: Model.h:50
A class for particles.
Definition: Particle.h:26
QCD()
Constructor.
Definition: QCD.cpp:29
@ NEUTRINO_2
Definition: QCD.h:313
@ NEUTRINO_1
Definition: QCD.h:311
@ MU
Definition: QCD.h:314
@ ELECTRON
Definition: QCD.h:312
@ NEUTRINO_3
Definition: QCD.h:315
@ TAU
Definition: QCD.h:316
double dAle5Mz
The five-flavour hadronic contribution to the electromagnetic coupling, , used as input for FlagMWinp...
EWSMThreeLoopEW * myThreeLoopEW
A pointer to an object of type EWSMThreeLoopEW.
double delSin2th_b
The theoretical uncertainty in , denoted as .
double A
The CKM parameter in the Wolfenstein parameterization.
bool requireCKM
An internal flag to control whether the CKM matrix has to be recomputed.
std::string FlagRhoZ
A string for the model flag RhoZ.
double Mz
The mass of the boson in GeV.
EWSMThreeLoopQCD * myThreeLoopQCD
A pointer to an object of type EWSMThreeLoopQCD.
double delGammaWlv
The theoretical uncertainty in , denoted as .
double GammaW_cache
A cache of the value of .
double delMw
The theoretical uncertainty in , denoted as , in GeV.
bool flag_order[orders_EW_size]
An array of internal flags controlling the inclusions of higher-order corrections.
EWSMTwoLoopEW * myTwoLoopEW
A pointer to an object of type EWSMTwoLoopEW.
bool FlagFixMuwMut
A boolean for the model flag FixMuwMut.
bool useDeltaAlpha_cache
bool requireYn
An internal flag to control whether the neutrino Yukawa matrix has to be recomputed.
gsl_integration_workspace * w_GSL1
gslpp::matrix< gslpp::complex > Yn
The Yukawa matrix of the neutrinos.
EWSMTwoFermionsLEP2 * myTwoFermionsLEP2
A pointer to an object of type EWSMTwoFermionsLEP2.
Matching< StandardModelMatching, StandardModel > SMM
An object of type Matching.
gslpp::matrix< gslpp::complex > Yu
The Yukawa matrix of the up-type quarks.
std::string FlagMw
A string for the model flag Mw.
double delsigma0H
The theoretical uncertainty in , denoted as in nb.
double rhob
The CKM parameter in the Wolfenstein parameterization.
Particle leptons[6]
An array of Particle objects for the leptons.
double delSin2th_l
The theoretical uncertainty in , denoted as .
bool FlagMWinput
A boolean for the model flag MWinput.
Flavour SMFlavour
An object of type Flavour.
bool FlagWithoutNonUniversalVC
A boolean for the model flag WithoutNonUniversalVC.
bool FlagSMAux
A boolean for the model flag SMAux.
gslpp::matrix< gslpp::complex > Yd
The Yukawa matrix of the down-type quarks.
EWSMOneLoopEW * myOneLoopEW
A pointer to an object of type EWSMOneLoopEW.
double delR0c
The theoretical uncertainty in , denoted as .
std::string FlagKappaZ
A string for the model flag KappaZ.
double GF
The Fermi constant in .
EWSMApproximateFormulae * myApproximateFormulae
A pointer to an object of type EWSMApproximateFormulae.
double Mw_cache
A cache of the value of .
double DeltaAlphaLepton_cache
A cache of the value of .
double delGammaWqq
The theoretical uncertainty in , denoted as .
double delSin2th_q
The theoretical uncertainty in , denoted as .
bool FlagUseVud
A boolean for the model flag UseVud.
bool FlagNoApproximateGammaZ
A boolean for the model flag NoApproximateGammaZ.
gslpp::complex kappaZ_f_cache[12]
A cache of the value of .
double lambda
The CKM parameter in the Wolfenstein parameterization.
bool useDeltaAlphaLepton_cache
double etab
The CKM parameter in the Wolfenstein parameterization.
EWSMcache * myEWSMcache
A pointer to an object of type EWSMcache.
gslpp::complex rhoZ_f_cache[12]
A cache of the value of .
double mHl
The Higgs mass in GeV.
double ale
The fine-structure constant .
bool flagLEP2[NUMofLEP2RCs]
double AlsMz
The strong coupling constant at the Z-boson mass, .
double delGammaZ
The theoretical uncertainty in , denoted as , in GeV.
gslpp::matrix< gslpp::complex > Ye
The Yukawa matrix of the charged leptons.
double muw
A matching scale around the weak scale in GeV.
bool useRhoZ_f_cache[12]
double delR0b
The theoretical uncertainty in , denoted as .
EWSMTwoLoopQCD * myTwoLoopQCD
A pointer to an object of type EWSMTwoLoopQCD.
bool FlagWolfenstein
A boolean for the model flag Wolfenstein.
bool requireYe
An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed.
EWSMThreeLoopEW2QCD * myThreeLoopEW2QCD
A pointer to an object of type EWSMThreeLoopEW2QCD.
bool useKappaZ_f_cache[12]
bool FlagCacheInStandardModel
A flag for caching (true by default).
double DeltaAlpha_cache
A cache of the value of .
double delR0l
The theoretical uncertainty in , denoted as .

◆ ~StandardModel()

StandardModel::~StandardModel ( )
virtual

The default destructor.

Definition at line 154 of file StandardModel/src/StandardModel.cpp.

155{
156 if (IsModelInitialized()) {
157 if (myEWSMcache != NULL) delete(myEWSMcache);
158 if (myOneLoopEW != NULL) delete(myOneLoopEW);
159 if (myTwoLoopQCD != NULL) delete(myTwoLoopQCD);
160 if (myThreeLoopQCD != NULL) delete(myThreeLoopQCD);
161 if (myTwoLoopEW != NULL) delete(myTwoLoopEW);
162 if (myThreeLoopEW2QCD != NULL) delete(myThreeLoopEW2QCD);
163 if (myThreeLoopEW != NULL) delete(myThreeLoopEW);
164 if (myApproximateFormulae != NULL) delete(myApproximateFormulae);
165 if (myLeptonFlavour != NULL) delete(myLeptonFlavour);
166 /* BEGIN: REMOVE FROM THE PACKAGE */
167 if (myTwoFermionsLEP2 != NULL) delete(myTwoFermionsLEP2);
168 /* END: REMOVE FROM THE PACKAGE */
169 }
170}
bool IsModelInitialized() const
A method to check if the model is initialized.
Definition: Model.h:136
LeptonFlavour * myLeptonFlavour
A pointer to an object of the type LeptonFlavour.

Member Function Documentation

◆ A_f()

const double StandardModel::A_f ( const Particle  f) const
virtual

The left-right asymmetry in \(e^+e^-\to Z\to \ell \bar{\ell}\) at the \(Z\)-pole, \(\mathcal{A}_\ell\).

The asymmetry \(\mathcal{A}_\ell\) is given by

\[ \mathcal{A}_\ell = \frac{2\, {\rm Re}\left(g_{V}^\ell/g_{A}^\ell\right)} {1+\left[{\rm Re}\left(g_{V}^\ell/g_{A}^\ell\right)\right]^2}\,, \]

where the ratio of the effective couplings \(g_{V}^\ell/g_{A}^\ell\) is computed via the two-loop approximate formula of \(\sin^2\theta_{\rm eff}^{\,\ell}\), EWSMApproximateFormulae::sin2thetaEff_l(), when checkNPZff_linearized() returns true and the model flag KappaZ of StandardModel is set to APPROXIMATEFORMULA.

Parameters
[in]fa lepton or quark
Returns
\(\mathcal{A}_\ell\)

Reimplemented in NPbase, NPSMEFTd6General, NPZbbbar, and NPEpsilons.

Definition at line 1345 of file StandardModel/src/StandardModel.cpp.

1346{
1347 double Re_kappa = kappaZ_f(f).real();
1348 double Re_gV_over_gA = 1.0 - 4.0 * fabs(f.getCharge()) * Re_kappa * sW2();
1349 return ( 2.0 * Re_gV_over_gA / (1.0 + pow(Re_gV_over_gA, 2.0)));
1350}
double getCharge() const
A get method to access the particle charge.
Definition: Particle.h:97
virtual const gslpp::complex kappaZ_f(const Particle f) const
The effective leptonic neutral-current coupling in the SM.

◆ AFB()

const double StandardModel::AFB ( const Particle  f) const
virtual
Parameters
[in]fa lepton or quark
Returns

Reimplemented in NPbase, NPSMEFTd6General, NPZbbbar, and NPEpsilons.

Definition at line 1352 of file StandardModel/src/StandardModel.cpp.

1353{
1354 return (3.0 / 4.0 * A_f(leptons[ELECTRON]) * A_f(f));
1355}
virtual const double A_f(const Particle f) const
The left-right asymmetry in at the -pole, .

◆ AFB_NoISR_l()

const double StandardModel::AFB_NoISR_l ( const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8034 of file StandardModel/src/StandardModel.cpp.

8035{
8036 double ml = getLeptons(l_flavor).getMass();
8037 double AFB = myTwoFermionsLEP2->AFB_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8038
8039 return AFB;
8040}
double AFB_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
const Particle & getLeptons(const QCD::lepton p) const
A get method to retrieve the member object of a lepton.
virtual const double AFB(const Particle f) const
virtual const double Gamma_Z() const
The total decay width of the boson, .
virtual const double Mw() const
The SM prediction for the -boson mass in the on-shell scheme, .
Test Observable.

◆ AFB_NoISR_q()

const double StandardModel::AFB_NoISR_q ( const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8042 of file StandardModel/src/StandardModel.cpp.

8043{
8044 double mq = m_q(q_flavor, sqrt(s));
8045 double AFB = myTwoFermionsLEP2->AFB_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8046
8047 if (flagLEP2[QCDFSR])
8048 AFB *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, s);
8049
8050 return AFB;
8051}
double AFB_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double QCD_FSR_forAFB(const QCD::quark q, const double mf, const double s) const
double m_q(const QCD::quark q, const double mu, const orders order=FULLNLO) const

◆ AH_f()

gslpp::complex StandardModel::AH_f ( const double  tau) const

Fermionic loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings.

\(A^H_f(\tau)=2\tau [1+(1-\tau)f(\tau)]\)

Parameters
[in]

_form#4737, with \(M\) the mass of the fermion in the loop.

Returns
\(A^H_f(\tau)\)

Definition at line 3302 of file StandardModel/src/StandardModel.cpp.

3302 {
3303 return (2.0 * tau * (1.0 + (1.0 - tau) * f_triangle(tau)));
3304}
gslpp::complex f_triangle(const double tau) const
Loop function entering in the calculation of the effective and couplings.

◆ AH_W()

gslpp::complex StandardModel::AH_W ( const double  tau) const

W loop function entering in the calculation of the effective \(H\gamma\gamma\) coupling.

\(A^H_W(\tau)=-[2+3\tau + 3\tau*(2-\tau) f(\tau)]\)

Parameters
[in]

_form#4737, with \(M\) the mass of the fermion in the loop.

Returns
\(A^H_W(\tau)\)

Definition at line 3306 of file StandardModel/src/StandardModel.cpp.

3306 {
3307 return -(2.0 + 3.0 * tau + 3.0 * tau * (2.0 - tau) * f_triangle(tau));
3308}

◆ AHZga_f()

gslpp::complex StandardModel::AHZga_f ( const double  tau,
const double  lambda 
) const

Fermionic loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4737, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the fermion in the loop.

Returns
\(A^{HZ\gamma}_f(\tau,\lambda)\)

Definition at line 3310 of file StandardModel/src/StandardModel.cpp.

3310 {
3311 return I_triangle_1(tau, lambda) - I_triangle_2(tau, lambda);
3312}
gslpp::complex I_triangle_1(const double tau, const double lambda) const
Loop function entering in the calculation of the effective coupling.
gslpp::complex I_triangle_2(const double tau, const double lambda) const
Loop function entering in the calculation of the effective coupling.

◆ AHZga_W()

gslpp::complex StandardModel::AHZga_W ( const double  tau,
const double  lambda 
) const

W loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4737, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the fermion in the loop.

Returns
\(A^{HZ\gamma}_W(\tau,\lambda)\)

Definition at line 3314 of file StandardModel/src/StandardModel.cpp.

3314 {
3315 gslpp::complex tmp;
3316
3317 double tan2w = sW2() / cW2();
3318
3319 tmp = 4.0 * (3.0 - tan2w) * I_triangle_2(tau, lambda);
3320
3321 tmp = tmp + ((1.0 + 2.0 / tau) * tan2w - (5.0 + 2.0 / tau)) * I_triangle_1(tau, lambda);
3322
3323 return sqrt(cW2()) * tmp;
3324}
virtual const double cW2() const

◆ Ale()

const double StandardModel::Ale ( double  mu,
orders  order,
bool  Nf_thr = true 
) const

The running electromagnetic coupling \(\alpha_e(\mu)\) in the \(\overline{MS}\) scheme.

See [Huber:2005ig]

Parameters
[in]murenormalization scale \(\mu\) in GeV
[in]orderorder in the \(\alpha_e\) expansion as defined in the order enum in OrderScheme
[in]Nf_thrflag to activate flavour thresholds. Default: true
Returns
\(\alpha_e(\mu)\) in the \(\overline{MS}\) scheme

Definition at line 783 of file StandardModel/src/StandardModel.cpp.

784{
785 int i, nfAle = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAle;
786 double ale, aletmp, mutmp, aleMz = alphaMz();
787 orders fullord;
788
789 for (i = 0; i < CacheSize; ++i)
790 if ((mu == ale_cache[0][i]) && ((double) order == ale_cache[1][i]) &&
791 (AlsMz == ale_cache[2][i]) && (Mz == ale_cache[3][i]) &&
792 (mut == ale_cache[4][i]) && (mub == ale_cache[5][i]) &&
793 (muc == ale_cache[6][i])
794 && (double) Nf_thr == ale_cache[7][i] && aleMz == ale_cache[8][i])
795 return ale_cache[9][i];
796
797 switch (order)
798 {
799 case FULLNLO:
800 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr));
801 case FULLNNLO:
802 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr));
803 case FULLNNNLO:
804 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr) + Ale(mu, NNNLO, Nf_thr));
805 case LO:
806 if (nfAle == nfmu)
807 return(AleWithInit(mu, aleMz, Mz, order));
808 case NLO:
809 case NNLO:
810 case NNNLO:
811 if (nfAle == nfmu)
812 return(0.);
813 fullord = FullOrder(order);
814 if (nfAle > nfmu) {
815 mutmp = BelowTh(Mz);
816 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
817// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAle), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
818 for (i = nfAle - 1; i > nfmu; i--) {
819 mutmp = BelowTh(mutmp - MEPS);
820 aletmp = AleWithInit(mutmp, aletmp, AboveTh(mutmp) - MEPS, fullord);
821// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), aletmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
822 }
823 ale = AleWithInit(mu, aletmp, AboveTh(mu) - MEPS, order);
824 }
825
826 if (nfAle < nfmu) {
827 mutmp = AboveTh(Mz) - MEPS;
828 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
829// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
830 for (i = nfAle + 1; i < nfmu; i++) {
831 mutmp = AboveTh(mutmp) - MEPS;
832 aletmp = AleWithInit(mutmp, aletmp, BelowTh(mutmp) + MEPS, fullord);
833// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
834 }
835 ale = AleWithInit(mu, aletmp, BelowTh(mu) + MEPS, order);
836 }
837
839 ale_cache[0][0] = mu;
840 ale_cache[1][0] = (double) order;
841 ale_cache[2][0] = AlsMz;
842 ale_cache[3][0] = Mz;
843 ale_cache[4][0] = mut;
844 ale_cache[5][0] = mub;
845 ale_cache[6][0] = muc;
846 ale_cache[7][0] = (double) Nf_thr;
847 ale_cache[8][0] = aleMz;
848 ale_cache[9][0] = ale;
849
850 return ale;
851 default:
852 throw std::runtime_error("StandardModel::Ale(): " + orderToString(order) + " is not implemented.");
853 }
854}
@ FULLNNNLO
Definition: OrderScheme.h:40
@ NNLO
Definition: OrderScheme.h:36
@ NNNLO
Definition: OrderScheme.h:37
@ NLO
Definition: OrderScheme.h:35
@ FULLNNLO
Definition: OrderScheme.h:39
@ FULLNLO
Definition: OrderScheme.h:38
double mut
The threshold between six- and five-flavour theory in GeV.
Definition: QCD.h:1021
double muc
The threshold between four- and three-flavour theory in GeV.
Definition: QCD.h:1023
const double BelowTh(const double mu) const
The active flavour threshold below the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:559
const std::string orderToString(const orders order) const
Converts an object of the enum type "orders" to the corresponding string.
Definition: QCD.cpp:95
const double AboveTh(const double mu) const
The active flavour threshold above the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:547
const double Nf(const double mu) const
The number of active flavour at scale .
Definition: QCD.cpp:571
const orders FullOrder(orders order) const
Return the FULLORDER enum corresponding to order.
Definition: QCD.cpp:728
double mub
The threshold between five- and four-flavour theory in GeV.
Definition: QCD.h:1022
void CacheShift(double cache[][5], int n) const
A member used to manage the caching for this class.
const double Ale(double mu, orders order, bool Nf_thr=true) const
The running electromagnetic coupling in the scheme.
const double AleWithInit(double mu, double alsi, double mu_i, orders order) const
double ale_cache[10][CacheSize]
Cache for .
virtual const double alphaMz() const
The electromagnetic coupling at the -mass scale, .
static const int CacheSize
Defines the depth of the cache.
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:33

◆ ale_OS()

const double StandardModel::ale_OS ( const double  mu,
orders  order = FULLNLO 
) const

The running electromagnetic coupling \(\alpha(\mu)\) in the on-shell scheme.

See [Baikov:2012rr].

Parameters
[in]murenormalization scale \(\mu\) in GeV.
[in]orderLO/FULLNLO
Returns
\(\alpha(\mu)\) in the on-shell scheme
Attention
This function is applicable to the scale where the three charged leptons and the five quarks, not the top quark, run in the loops.

Definition at line 611 of file StandardModel/src/StandardModel.cpp.

612{
613 if (mu < 50.0)
614 throw std::runtime_error("out of range in StandardModel::ale_OS()");
615
616 double N = 20.0 / 3.0;
617 double beta1 = N / 3.0;
618 double beta2 = N / 4.0;
619 double alpha_ini = alphaMz();
620 double v = 1.0 + 2.0 * beta1 * alpha_ini / M_PI * log(Mz / mu);
621
622 switch (order) {
623 case LO:
624 return ( alpha_ini / v);
625 case FULLNLO:
626 return ( alpha_ini / v * (1.0 - beta2 / beta1 * alpha_ini / M_PI * log(v) / v));
627 default:
628 throw std::runtime_error("Error in StandardModel::ale_OS()");
629 }
630}
const double v() const
The Higgs vacuum expectation value.

◆ AleWithInit()

const double StandardModel::AleWithInit ( double  mu,
double  alsi,
double  mu_i,
orders  order 
) const
private

Definition at line 856 of file StandardModel/src/StandardModel.cpp.

857{
858 if (fabs(mu - mu_i) < MEPS) return(alei);
859
860 double nf = Nf(mu), alsi = (mu_i == Mz ? AlsMz : Als(mu_i, FULLNNNLO, true, true));
861 double b00e = Beta_e(00, nf), b00s = Beta_s(00, nf);
862 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
863 double logv = log(1. + b00s * alsi / 2. / M_PI * log(mu / mu_i)), logve = log(ve);
864
865 switch (order)
866 {
867 case LO:
868 return (alei / ve);
869 case NLO:
870 return (- alei * alei / 4. / M_PI / ve / ve * (Beta_e(10, nf) / b00e * logve - Beta_e(01, nf) / b00s * logv) );
871 // Higher order terms ? Need to understand eq. (35)
872 case FULLNLO:
873 return (AleWithInit(mu, alei, mu_i, LO) + AleWithInit(mu, alei, mu_i, NLO));
874 default:
875 throw std::runtime_error("StandardModel::AleWithInit(): " + orderToString(order) + " is not implemented.");
876 }
877}
const double Beta_s(int nm, unsigned int nf) const
QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066.
const double Als(const double mu, const orders order, const bool Nf_thr, const bool qed_flag) const
The running QCD coupling in the scheme including QED corrections.
const double Beta_e(int nm, unsigned int nf) const
QED beta function coefficients - eq. (36) hep-ph/0512066.

◆ alphaMz()

const double StandardModel::alphaMz ( ) const
virtual

The electromagnetic coupling at the \(Z\)-mass scale, \(\alpha(M_Z^2)=\alpha/(1-\Delta\alpha(M_Z^2))\).

The radiative corrections are included with Dyson resummation:

\[ \alpha(M_Z^2) = \frac{\alpha}{1 - \Delta\alpha(M_Z^2)}. \]

Returns
\(\alpha(M_Z^2)\)

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 944 of file StandardModel/src/StandardModel.cpp.

945{
946 return (ale / (1.0 - DeltaAlpha()));
947// return(1./127.918); // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
948// return(1./127.955); // FOR HEFFDF1 TEST: VALUE IN 2007.04191
949}
const double DeltaAlpha() const
The total corrections to the electromagnetic coupling at the -mass scale, denoted as .

◆ alrmoller()

const double StandardModel::alrmoller ( const double  q2,
const double  y 
) const
virtual

The computation of the parity violating asymmetry in Moller scattering.

Parameters
[in]q2the \(Q^2\) of the process
[in]y
Returns
\(A_{LR}\)

Reimplemented in NPbase.

Definition at line 2769 of file StandardModel/src/StandardModel.cpp.

2770{
2771 // functions and inputs
2772 double alrmoller;
2773
2774 // which alfa is this? => alpha(0). is this ale?
2775
2776 // parity violation asymmetry
2777 // --------------------------
2778 alrmoller=-GF*q2*(1.0-y)/(sqrt(2.0)*M_PI*ale*(1.0+pow(y,4)+pow(1.0-y,4)))*Qwemoller(q2,y);
2779
2780 return alrmoller;
2781}
virtual const double alrmoller(const double q2, const double y) const
The computation of the parity violating asymmetry in Moller scattering.
virtual const double Qwemoller(const double q2, const double y) const
The computation of the electron's weak charge.

◆ Als() [1/3]

const double QCD::Als ( const double  mu,
const int  Nf_in,
const orders  order = FULLNLO 
) const

Computes the running strong coupling \(\alpha_s(\mu)\) with \(N_f\) active flavours in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda().

Parameters
[in]muthe scale \(\mu\) in GeV
[in]Nf_innumber of active flavours
[in]orderorder in the \(\alpha_s\) expansion as defined in OrderScheme
Returns
the strong coupling constant \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme with \(N_f\) active flavours

Definition at line 839 of file QCD.cpp.

784{
785 switch (order)
786 {
787 case LO:
788 realorder = order;
789 return AlsByOrder(mu, Nf, LO);
790 case FULLNLO:
791 realorder = order;
792 return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO));
793 case FULLNNLO:
794 realorder = order;
795 return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO) + AlsByOrder(mu, Nf, NNLO));
796 case FULLNNNLO:
797 realorder = order;
798 return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO) + AlsByOrder(mu, Nf, NNLO) + AlsByOrder(mu, Nf, NNNLO));
799 default:
800 throw std::runtime_error("QCD::Als(): " + orderToString(order) + " is not implemented.");
801 }
802}
const double AlsByOrder(const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
Definition: QCD.cpp:804

◆ Als() [2/3]

const double StandardModel::Als ( const double  mu,
const orders  order,
const bool  Nf_thr,
const bool  qed_flag 
) const
inline

The running QCD coupling \(\alpha(\mu)\) in the \(\overline{MS}\) scheme including QED corrections.

See [Huber:2005ig]

Parameters
[in]murenormalization scale \(\mu\) in GeV.
[in]orderorder in the \(\alpha_s\) expansion as defined in OrderScheme
[in]Nf_thrtrue: \(n_f\) = Nf(mu), false: \(n_f\) = Nf(AlsM)
[in]qed_flaginclude \(\alpha_e\) corrections to the requested order in \(\alpha_s\). The \(\alpha_s\alpha_e\) term is included if NNNLO is requested. Default: false
Returns
\(\alpha(\mu)\) in the \(\overline{MS}\) scheme

Definition at line 1120 of file StandardModel.h.

1121 {
1122 if (qed_flag && order == FULLNNNLO)
1123 return AlsE(mu, order, Nf_thr);
1124
1125 return Als(mu, order, Nf_thr);
1126 }
const double AlsE(double mu, orders order, bool Nf_thr) const

◆ Als() [3/3]

const double QCD::Als ( const double  mu,
const orders  order = FULLNLO,
const bool  Nf_thr = true 
) const

Definition at line 826 of file QCD.cpp.

763{
764 switch (order)
765 {
766 case LO:
767 realorder = order;
768 return AlsByOrder(mu, LO, Nf_thr);
769 case FULLNLO:
770 realorder = order;
771 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr));
772 case FULLNNLO:
773 realorder = order;
774 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr));
775 case FULLNNNLO:
776 realorder = order;
777 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr) + AlsByOrder(mu, NNNLO, Nf_thr));
778 default:
779 throw std::runtime_error("QCD::Als(): " + orderToString(order) + " is not implemented.");
780 }
781}

◆ AlsE()

const double StandardModel::AlsE ( double  mu,
orders  order,
bool  Nf_thr 
) const
private

Definition at line 680 of file StandardModel/src/StandardModel.cpp.

681{
682 switch (order)
683 {
684 case FULLNNNLO:
685 realorder = order;
686 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr) + AlsEByOrder(mu, NNNLO, Nf_thr));
687 default:
688 throw std::runtime_error("StandardModel::AlsE(): " + orderToString(order) + " is not implemented.");
689 }
690}
const double AlsEByOrder(double mu, orders order, bool Nf_thr) const

◆ AlsEByOrder()

const double StandardModel::AlsEByOrder ( double  mu,
orders  order,
bool  Nf_thr 
) const
private

Definition at line 692 of file StandardModel/src/StandardModel.cpp.

693{
694 int i, nfAls = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAls;
695 double als, alstmp, mutmp;
696 orders fullord;
697
698 for (i = 0; i < CacheSize; ++i)
699 if ((mu == als_cache[0][i]) && ((double) order == als_cache[1][i]) &&
700 (AlsMz == als_cache[2][i]) && (Mz == als_cache[3][i]) &&
701 (mut == als_cache[4][i]) && (mub == als_cache[5][i]) &&
702 (muc == als_cache[6][i]) && (double) true == als_cache[7][i]
703 && (double) Nf_thr == als_cache[8][i] && alphaMz() == als_cache[9][i])
704 return als_cache[10][i];
705
706 switch (order)
707 {
708 case NNNLO:
709 if (nfAls == nfmu)
710 als = AlsEWithInit(mu, AlsMz, Mz, nfAls, order);
711 fullord = FullOrder(order);
712 if (nfAls > nfmu) {
713 mutmp = BelowTh(Mz);
714 alstmp = AlsEWithInit(mutmp, AlsMz, Mz, nfAls, realorder);
715 alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAls), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
716 for (i = nfAls - 1; i > nfmu; i--) {
717 mutmp = BelowTh(mutmp - MEPS);
718 alstmp = AlsEWithInit(mutmp, alstmp, AboveTh(mutmp) - MEPS, i, realorder);
719 alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), alstmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
720 }
721 als = AlsEWithInit(mu, alstmp, AboveTh(mu) - MEPS, nfmu, order);
722 }
723
724 if (nfAls < nfmu) {
725 mutmp = AboveTh(Mz) - MEPS;
726 alstmp = AlsEWithInit(mutmp, AlsMz, Mz, nfAls, realorder);
727 alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
728 for (i = nfAls + 1; i < nfmu; i++) {
729 mutmp = AboveTh(mutmp) - MEPS;
730 alstmp = AlsEWithInit(mutmp, alstmp, BelowTh(mutmp) + MEPS, i, realorder);
731 alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
732 }
733 als = AlsEWithInit(mu, alstmp, BelowTh(mu) + MEPS, nfmu, order);
734 }
735
737 als_cache[0][0] = mu;
738 als_cache[1][0] = (double) order;
739 als_cache[2][0] = AlsMz;
740 als_cache[3][0] = Mz;
741 als_cache[4][0] = mut;
742 als_cache[5][0] = mub;
743 als_cache[6][0] = muc;
744 als_cache[7][0] = (double) true;
745 als_cache[8][0] = (double) Nf_thr;
746 als_cache[9][0] = alphaMz();
747 als_cache[10][0] = als;
748
749 return als;
750 default:
751 throw std::runtime_error("StandardModel::AlsEByOrder(): " + orderToString(order) + " is not implemented.");
752 }
753}
const double NfThresholdCorrections(double mu, double M, double als, int nf, orders order) const
Threshold corrections in matching with from eq. (34) of hep-ph/0512060.
Definition: QCD.cpp:709
const double MassOfNf(int nf) const
The Mbar mass of the heaviest quark in the theory with Nf active flavour.
Definition: QCD.cpp:745
double als_cache[11][CacheSize]
Cache for .
const double AlsEWithInit(double mu, double alsi, double mu_i, const int nf_i, orders order) const

◆ AlsEWithInit()

const double StandardModel::AlsEWithInit ( double  mu,
double  alsi,
double  mu_i,
const int  nf_i,
orders  order 
) const
private

Definition at line 755 of file StandardModel/src/StandardModel.cpp.

756{
757 double nf = (double) nf_i, alei = Ale(mu_i, FULLNLO); // CHANGE ME!
758 double b00s = Beta_s(00, nf), b00e = Beta_e(00, nf);
759 double v = 1. + b00s * alsi / 2. / M_PI * log(mu / mu_i);
760 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
761 double logv = log(v), logve = log(ve);
762 double rho = 1. / (1. + b00e * alei / b00s / alsi);
763 double als = AlsWithInit(mu, alsi, mu_i, nf, order);
764 double b01s = Beta_s(01,nf), b01s00e = b01s / b00e;
765
766 switch (order)
767 {
768 case NNNLO:
769 als += alsi * alsi * alei / 4. / 4. / M_PI / M_PI / v / v / ve * (Beta_s(02, nf) / b00e *
770 (ve - 1.) + Beta_s(11, nf) / b00s * rho * ve * (logve - logv) + b01s00e * Beta_e(10, nf) /
771 b00e * (logve - ve + 1.) + b01s * Beta_s(10, nf) / b00s / b00s * rho * logv +
772 b01s00e * Beta_e(01, nf) / b00s * (rho * ve * (logv - logve) - logv));
773 break;
774 case FULLNNNLO:
775 return (AlsWithInit(mu, alsi, mu_i, nf_i, LO) + AlsWithInit(mu, alsi, mu_i, nf_i, NLO)+ AlsWithInit(mu, alsi, mu_i, nf_i, NNLO) + AlsEWithInit(mu, alsi, mu_i, nf_i, NNNLO));
776 default:
777 throw std::runtime_error("StandardModel::AlsEWithInit(): " + orderToString(order) + " is not implemented.");
778 }
779
780 return (als);
781}
const double AlsWithInit(const double mu, const double alsi, const double mu_i, const int nf, const orders order) const
Computes the running strong coupling from in the scheme, where it is forbidden to across a flavour...
Definition: QCD.cpp:627

◆ Alstilde5()

const double StandardModel::Alstilde5 ( const double  mu) const

The value of \(\frac{\alpha_s^{\mathrm{FULLNLO}}}{4\pi}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\) and full EW corrections.

Parameters
[in]muthe scale at which \(\alpha_s\) has to be computed
Returns
\(\alpha_s^{\mathrm{FULLNLO}}(\mu)\) with \(n_f = 4\5\)

Definition at line 951 of file StandardModel/src/StandardModel.cpp.

952{
953 double mu_0 = Mz;
954 double alphatilde_e = alphaMz()/4./M_PI;
955 double alphatilde_s = AlsMz/4./M_PI;
956 unsigned int nf = 5;
957
958 double B00S = Beta0(nf), B10S = Beta1(nf), B20S = Beta2(nf), B30S = gsl_sf_zeta_int(3) * 352864./81. - 598391./1458,
959 B01S = -22./9., B11S = -308./27., B02S = 4945./243.;
960
961 double B00E = 80./9., B01E = 176./9., B10E = 464./27.;
962
963 double B10soB00s = B10S / B00S;
964 double B01soB00e = B01S/B00E;
965
966 double vs= 1. + 2. * B00S * alphatilde_s * log(mu/ mu_0);
967 double ve= 1. - 2. * B00E * alphatilde_e * log(mu/ mu_0);
968 double ps= B00S * alphatilde_s /(B00S * alphatilde_s + B00E * alphatilde_e);
969
970 double logve = log(ve);
971 double logvs = log(vs);
972 double logeos = log(ve/vs);
973 double logsoe = log(vs/ve);
974 double asovs = alphatilde_s/vs;
975 double aeove = alphatilde_e/ve;
976
977 double result = 0;
978
979 result = asovs - pow(asovs, 2) * (logvs * B10soB00s - logve * B01soB00e)
980 + pow(asovs, 3) * ((1. - vs) * B20S / B00S + B10soB00s * B10soB00s * (logvs * logvs - logvs
981 + vs - 1.) + B01soB00e * B01soB00e * logve * logve + (-2. * logvs * logve
982 + ps * ve * logve) * B01S * B10S/(B00E * B00S))
983 + pow(asovs, 4) * (0.5 * B30S *(1. - vs * vs)/ B00S + ((2. * vs - 3.) * logvs + vs * vs
984 - vs) * B20S * B10soB00s /(B00S) + B10soB00s * B10soB00s * B10soB00s * (- pow(logvs,3)
985 + 5. * pow(logvs,2) / 2. + 2. * (1. - vs) * logvs - (vs - 1.) * (vs - 1.)* 0.5))
986 + pow(asovs, 2) * (aeove) * ((ve - 1.) * B02S / B00E
987 + ps * ve * logeos * B11S /B00S +(logve - ve + 1.) * B01soB00e * B10E/(B00E)
988 + logvs * ps * B01S * B10soB00s/(B00S) +(logsoe * ve * ps - logvs) * B01soB00e * B01E/( B00S));
989 return (result);
990}
const double Beta2(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:611
const double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:606
const double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:601

◆ amuon()

const double StandardModel::amuon ( ) const
virtual

The computation of the anomalous magnetic moment of the muon \(a_\mu=(g_\mu-2)/2\).

Returns
\(a_\mu=(g_\mu-2)/2\)

Reimplemented in NPbase.

Definition at line 2441 of file StandardModel/src/StandardModel.cpp.

2442{
2443
2444// output
2445 double amu;
2446
2447// -----------------------------------------------------------------
2448// qed contributions
2449 double amuqed,alfa0pi;
2450
2451// ew contributions
2452 double amuew,amuew1,amuew2b,amuew2f,amuew2,amuew3,cft,cf,corr1amuew2, corr2amuew2,corrwaamuew2,al,aq,b1; //,b2;
2453
2454// qcd contributions
2455 double amuhad,amuhhovp,amuhholbl,amuhho,amuhlo;
2456
2457// -----------------------------------------------------------------
2458// numerical constants
2459 const double sn2=0.2604341;
2460
2461// -----------------------------------------------------------------
2462// SM parameters
2463
2464// light quark masses. constituent masses
2465 const double umass=0.3;
2466 const double dmass=0.3;
2467 const double smass=0.5;
2468
2469 const double mum=leptons[MU].getMass(),taum=leptons[TAU].getMass();
2470 const double cqm=quarks[CHARM].getMass(),bqm=quarks[BOTTOM].getMass();
2471
2472// all fermion masses (constituent masses for u,d,s. for the other from model)
2473 double fermmass[9]={leptons[ELECTRON].getMass(),mum,taum,
2474 dmass,umass,
2475 smass,cqm,
2476 bqm,mtpole};
2477
2478// w mass and on-shell weak angle
2479 double MwSM, s2;
2480
2481// running of alfa_qed and dummy variable
2482 double aqed;
2483
2484// for the 2-loop bosonic corrections
2485 double a2l[4]={0.,0.,0.,0.},b2l[4]={0.,0.,0.,0.},sw2l[4]={0.,0.,0.,0.};
2486
2487// for the 2-loop corrections from the renormalization of weak angle
2488 double c2lren[6]={0.,0.,0.,0.,0.,0.};
2489
2490// w mass
2491 MwSM=Mw();
2492
2493 s2=1.0 - MwSM*MwSM/Mz/Mz;
2494
2495//------------------------------------------------------------------
2496// qed contribution to amu (arxiv: hep-ph/0606174)
2497 alfa0pi=ale/M_PI;
2498
2499 amuqed=alfa0pi*(0.5+alfa0pi*(0.765857410+alfa0pi*(24.05050964+
2500 + alfa0pi*(130.8055+663.0*alfa0pi))));
2501
2502//-----------------------------------------------------------------
2503// one-loop ew correction(phys.rev.lett. 76,3267 (1996))
2504
2505 amuew1=5.0*GF*mum*mum/(24.0*sqrt(2.0)*M_PI*M_PI)*(1.0+
2506 + 0.2*(1.0-4.0*s2)*(1.0-4.0*s2));
2507
2508//-----------------------------------------------------------------
2509// two-loop computation
2510
2511// these depend on aqed and since we are going to include also three-loop
2512// effects we need to include in the two-loop results the running of aqed at
2513// 1-loop up to the scale mum
2514//-----------------------------------------------------------------
2515// running of alpha em down to mu mass (1-loop)
2516
2517 aqed = 1.0/ale + 2.0 * log(fermmass[0]/mum)/3.0/M_PI;
2518
2519 aqed = 1.0/aqed;
2520
2521//-----------------------------------------------------------------
2522// two-loop ew bosonic correction(phys.rev.lett. 76,3267 (1996))
2523
2524// previous definitions
2525 a2l[0]=19.0/36.0-99.0*sn2/8.0-1.0*2.0*log(mHl/MwSM)/24.0;
2526
2527 b2l[0]=155.0/192.0+3.0*M_PI*M_PI/8.0-9.0*sn2/8.0+3.0*2.0*pow(log(mHl/MwSM),2)/2.0-21.0*2.0*log(mHl/MwSM)/16.0;
2528
2529 sw2l[0]=1.0/s2;
2530
2531 a2l[1]=-859.0/18.0+11.0*M_PI/sqrt(3.0)+20.0*M_PI*M_PI/9.0+ 393.0*sn2/8.0-65.0*2.0*log(MwSM/mum)/9.0+ 31.0*2.0*log(mHl/MwSM)/72.0;
2532
2533 b2l[1]=433.0/36.0+5.0*M_PI*M_PI/24.0-51.0*sn2/8.0+ 3.0*4.0*pow(log(mHl/MwSM),2)/8.0+9.0*2.0*log(mHl/MwSM)/4.0;
2534
2535 sw2l[1]=1.0;
2536
2537 a2l[2]=165169.0/1080.0-385.0*M_PI/(6.0*sqrt(3.0))-29.0*M_PI*M_PI/6.0+ 33.0*sn2/8.0+92.0*2.0*log(MwSM/mum)/9.0- 133.0*2.0*log(mHl/MwSM)/72.0;
2538
2539 b2l[2]=-431.0/144.0+3.0*M_PI*M_PI/8.0+315.0*sn2/8.0+ 3.0*4.0*pow(log(mHl/MwSM),2)/2.0-11.0*2.0*log(mHl/MwSM)/8.0;
2540
2541 sw2l[2]=s2;
2542
2543 a2l[3]=-195965.0/864.0+265.0*M_PI/(3.0*sqrt(3.0))+163.0*M_PI*M_PI/18.0+ 223.0*sn2/12.0-184.0*2.0*log(MwSM/mum)/9.0- 5.0*2.0*log(mHl/MwSM)/8.0;
2544
2545 b2l[3]=433.0/216.0+13.0*M_PI*M_PI/24.0+349.0*sn2/24.0+ 21.0*4.0*pow(log(mHl/MwSM),2)/8.0-49.0*2.0*log(mHl/MwSM)/12.0;
2546
2547 sw2l[3]=s2*s2;
2548
2549// computation
2550
2551 amuew2b=0.0;
2552
2553 for (int i = 0; i < 4; ++i) {
2554 amuew2b=amuew2b+a2l[i]*sw2l[i]+(MwSM*MwSM/mHl/mHl)*b2l[i]*sw2l[i];
2555 }
2556
2557// the contribution with the running of aqed up to the mu scale
2558 amuew2b=mum*mum*aqed*GF*amuew2b/(8.0*sqrt(2.0)*M_PI*M_PI*M_PI);
2559
2560//-----------------------------------------------------------------
2561// two-loop ew fermionic correction(phys.rev.d 52,r2619(1995)
2562
2563// contribution from higgs boson diagram
2564 if (mHl < (mtpole-10.0)) {
2565 cft=-104.0/45.0-16.0*2.0*log(mtpole/mHl)/15.0;
2566 } else if (mHl > (mtpole+10)) {
2567 cft=-(mtpole*mtpole/mHl/mHl)*(24.0/5.0+8.0*M_PI*M_PI/15.0+
2568 + 8.0/5.0*pow(2.0*log(mHl/mtpole)-1.0,2));
2569 } else {
2570 cft=-(32.0/5.0)*(1.0-9.0*sn2/4.0);
2571 }
2572
2573 cf=pow((umass*cqm*Mz),(4.0/3.0));
2574
2575 cf=cf/(pow((dmass*smass*bqm),(1.0/3.0))*mum*mum*taum);
2576
2577 cf=-18.0*log(cf)/5.0-3.0*mtpole*mtpole/(16.0*s2*MwSM*MwSM)- 3.0*2.0*log(mtpole/MwSM)/(10.0*s2)- 8.0*2.0*log(mtpole/Mz)/5.0-41.0/5.0-7.0/(10.0*s2)+ 8.0*M_PI*M_PI/15.0+cft;
2578
2579// the contribution with the running of aqed up to the mu scale
2580 amuew2f=5.0*GF*mum*mum*cf*aqed/(24.0*sqrt(2.0)*M_PI*M_PI*M_PI);
2581
2582//-----------------------------------------------------------------
2583// corrections from hadronic loops (phys.rev.d 67,073006(2003))
2584// i also include the running here even though in the previous reference seems that it is not included
2585// first family (eqs. (60) and (61))
2586 corr1amuew2=-aqed*GF*mum*mum/(8.0*M_PI*M_PI*M_PI*sqrt(2.0))*(8.41- log(pow(umass,8)/(pow(mum,6)*pow(dmass,2)))-17.0/2.0);
2587// second family (eqs. (65) and (66))
2588 corr2amuew2=-aqed*GF*mum*mum/(8.0*M_PI*M_PI*M_PI*sqrt(2.0))*(17.1- log(pow(cqm,8)/(pow(mum,6)*pow(smass,2)))-47.0/6.0+8.0*M_PI*M_PI/9.0);
2589
2590//-----------------------------------------------------------------
2591// corrections from the renormalization of the weak mixing
2592// terms prop. to (1-4s2) included in eq. (7) of phys.rev.d 67,073006(2003)
2593// and neglected in the previous references
2594
2595 corrwaamuew2=-43.0*31.0*(1.0-4.0*s2)*(1.0-4.0*s2)/(215.0*3.0)*log(Mz/mum);
2596
2597 c2lren[0]=(72.0/135.0)*(-1.0+2.0*s2)*(1.0-4.0*s2); //leptons
2598 c2lren[1]=(72.0/135.0)*(-1.0+2.0*s2/3.0)*(1.0-4.0*s2); //d-quark
2599 c2lren[2]=-(144.0/135.0)*(1.0-4.0*s2/3.0)*(1.0-4.0*s2); //u-quark
2600 c2lren[3]=c2lren[1];//d-quark
2601 c2lren[4]=c2lren[2]; //u-quark
2602 c2lren[5]=c2lren[1]; //d-quark
2603
2604 for (int i = 2; i < 8; ++i) {
2605 corrwaamuew2=corrwaamuew2+c2lren[i-2]*log(Mz/fermmass[i]);
2606 }
2607
2608 corrwaamuew2=5*GF*mum*mum*aqed/(24.0*sqrt(2.0)*M_PI*M_PI*M_PI)*corrwaamuew2;
2609
2610// finally i also add the small correction to the eq.8
2611 corrwaamuew2=corrwaamuew2-0.2e-11;
2612
2613//-----------------------------------------------------------------
2614// total 2-loop ew contribution
2615 amuew2=amuew2b+amuew2f+corr1amuew2+corr2amuew2+corrwaamuew2;
2616
2617//-----------------------------------------------------------------
2618// three-loop ew correction(phys.rev.d 67,073006(2003)
2619
2620 al=2789.0*log(Mz/mum)*log(Mz/mum)/90.0- 302.0*log(Mz/taum)*log(Mz/taum)/45.0+ 72.0*log(Mz/taum)*log(Mz/mum)/5.0;
2621
2622 aq=-2662.0*log(Mz/bqm)*log(Mz/bqm)/1215.0+11216.0*log(Mz/cqm)*log(Mz/cqm)/1215.0+1964.0*log(Mz/umass)*log(Mz/umass)/405.0+24.0*log(Mz/bqm)*log(Mz/mum)/5.0-96.0*log(Mz/cqm)*log(Mz/mum)/5.0-48.0*log(Mz/umass)*log(Mz/mum)/5.0+32.0*log(Mz/bqm)*log(Mz/cqm)/405.0+32.0*log(Mz/bqm)*log(Mz/umass)/135.0;
2623
2624 b1=-179.0/45.0*(log(Mz/bqm)*log(Mz/bqm)/3.0+log(Mz/taum)*log(Mz/taum)+4.0*log(Mz/cqm)*log(Mz/cqm)/3.0+2.0*log(Mz/umass)*log(Mz/umass)+2.0*log(Mz/mum)*log(Mz/mum))+2.0/5.0*(log(bqm/taum)*log(bqm/taum)+4.0/3.0*log(bqm/cqm)*log(bqm/cqm)+2.0*log(bqm/umass)*log(bqm/umass)+2.0*log(bqm/mum)*log(bqm/mum) )-8.0/5.0*(2.0*log(cqm/umass)*log(cqm/umass)+2.0*log(cqm/mum)*log(cqm/mum))+6.0/5.0*(4.0/3.0*log(taum/cqm)*log(taum/cqm)+2.0*log(taum/umass)*log(taum/umass)+2.0*log(taum/mum)*log(taum/mum))-8.0*log(umass/mum)*log(umass/mum)/5.0;
2625
2626 // b2 is not used, as it can be absorved in the two loop part if alpha(m_mu) is used instead of alpha(Mz), as done above
2627 // b2=2.0/5.0*(2.0*log(Mz/mum)+2.0*log(Mz/umass)+4.0*log(Mz/cqm)/3.0+log(Mz/taum)+log(Mz/bqm)/3.0)*(215.0*log(Mz/mum)/9.0-4.0*log(Mz/umass)-8.0*log(Mz/cqm)+6.0*log(Mz/taum)+2.0*log(Mz/bqm));
2628
2629// the final correction(it is implied aqed at mum for the 2-loop
2630// correction
2631
2632 amuew3=amuew1*(ale*ale/M_PI/M_PI)*(al+aq+b1);
2633
2634//-----------------------------------------------------------------
2635// total ew correction
2636
2637 amuew=amuew1+amuew2+amuew3;
2638
2639//-----------------------------------------------------------------
2640// hadronic contributions (arxiv: 0908.4300 & 1001.5401 [hep-ph])
2641
2642// leading order: vacuum polarization (arxiv: 0908.4300 [hep-ph])
2643 amuhlo=6955.e-11;
2644
2645// higher order: vacuum polarization
2646 amuhhovp=-97.9e-11;
2647
2648// higher order: light-by-light
2649 amuhholbl=105.e-11;
2650
2651 amuhho=amuhhovp+amuhholbl;
2652
2653// total hadronic contribution
2654
2655 amuhad=amuhlo+amuhho;
2656
2657//-----------------------------------------------------------------
2658// final value for the muon (g-2)/2
2659
2660 amu=amuqed+amuew+amuhad;
2661
2662//-----------------------------------------------------------------
2663
2664 return amu;
2665
2666}
@ BOTTOM
Definition: QCD.h:329
@ CHARM
Definition: QCD.h:326
Particle quarks[6]
The vector of all SM quarks.
Definition: QCD.h:1027
A class for , the pole mass of the top quark.
Definition: masses.h:164

◆ Beta_e()

const double StandardModel::Beta_e ( int  nm,
unsigned int  nf 
) const

QED beta function coefficients - eq. (36) hep-ph/0512066.

Parameters
nmpowers of alpha_s and alpha_e as an integer
nfnumber of active flavor
Returns
coefficient of the QED beta function

Definition at line 660 of file StandardModel/src/StandardModel.cpp.

661{
662 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
663 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
664 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
665 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
666
667 switch(nm)
668 {
669 case 00:
670 return(4./3. * (Qbar2 * Nc + 3.)); // QL^2 = 1
671 case 10:
672 return(4. * (Qbar4 * Nc + 3.));
673 case 01:
674 return(4. * CF * Nc * Qbar2);
675 default:
676 throw std::runtime_error("StandardModel::Beta_e(): case not implemented");
677 }
678}
double CF
Definition: QCD.h:1026
double Nc
The number of colours.
Definition: QCD.h:1025

◆ Beta_s()

const double StandardModel::Beta_s ( int  nm,
unsigned int  nf 
) const

QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066.

Parameters
nmpowers of alpha_s and alpha_e as an integer
nfnumber of active flavor
Returns
coefficient of the QCD beta function

Definition at line 632 of file StandardModel/src/StandardModel.cpp.

633{
634 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
635 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
636 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
637 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
638
639 switch(nm)
640 {
641 case 00:
642 return(Beta0((double) nf));
643 case 10:
644 return(Beta1((double) nf));
645 case 20:
646 return(Beta2((double) nf));
647 case 30:
648 return(Beta3((double) nf));
649 case 01:
650 return(-4. * TF * Qbar2 );
651 case 11:
652 return((4. * CF - 8. * CA) * TF * Qbar2 );
653 case 02:
654 return(11./3. * TF * Qbar2 * Beta_e(00, nf) + 2. * TF * Qbar4);
655 default:
656 throw std::runtime_error("StandardModel::Beta_s(): case not implemented");
657 }
658}
double CA
Definition: QCD.h:1026
double TF
Definition: QCD.h:1026
const double Beta3(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:618

◆ BrHtobb()

const double StandardModel::BrHtobb ( ) const
virtual

The Br \((H\to b \bar{b})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to b \bar{b})\)

Definition at line 3697 of file StandardModel/src/StandardModel.cpp.

3698{
3699 return GammaHtobb()/GammaHTot();
3700}
virtual const double GammaHtobb() const
The in the Standard Model.
virtual const double GammaHTot() const
The total Higgs width in the Standard Model.

◆ BrHtocc()

const double StandardModel::BrHtocc ( ) const
virtual

The Br \((H\to c \bar{c})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to c \bar{c})\)

Definition at line 3687 of file StandardModel/src/StandardModel.cpp.

3688{
3689 return GammaHtocc()/GammaHTot();
3690}
virtual const double GammaHtocc() const
The in the Standard Model.

◆ BrHtogaga()

const double StandardModel::BrHtogaga ( ) const
virtual

The Br \((H\to \gamma \gamma)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to \gamma \gamma)\)

Definition at line 3672 of file StandardModel/src/StandardModel.cpp.

3673{
3674 return GammaHtogaga()/GammaHTot();
3675}
virtual const double GammaHtogaga() const
The in the Standard Model.

◆ BrHtogg()

const double StandardModel::BrHtogg ( ) const
virtual

The Br \(\(H\to gg)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to gg)\)

Definition at line 3652 of file StandardModel/src/StandardModel.cpp.

3653{
3654 return GammaHtogg()/GammaHTot();
3655}
virtual const double GammaHtogg() const
The in the Standard Model.

◆ BrHtomumu()

const double StandardModel::BrHtomumu ( ) const
virtual

The Br \((H\to \mu^+ \mu^-)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to \mu^+ \mu^-)\)

Definition at line 3677 of file StandardModel/src/StandardModel.cpp.

3678{
3679 return GammaHtomumu()/GammaHTot();
3680}
virtual const double GammaHtomumu() const
The in the Standard Model.

◆ BrHtoss()

const double StandardModel::BrHtoss ( ) const
virtual

The Br \((H\to s \bar{s})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to s \bar{s})\)

Definition at line 3692 of file StandardModel/src/StandardModel.cpp.

3693{
3694 return GammaHtoss()/GammaHTot();
3695}
virtual const double GammaHtoss() const
The in the Standard Model.

◆ BrHtotautau()

const double StandardModel::BrHtotautau ( ) const
virtual

The Br \((H\to \tau^+ \tau^-)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to \tau^+ \tau^-)\)

Definition at line 3682 of file StandardModel/src/StandardModel.cpp.

3683{
3684 return GammaHtotautau()/GammaHTot();
3685}
virtual const double GammaHtotautau() const
The in the Standard Model.

◆ BrHtoWWstar()

const double StandardModel::BrHtoWWstar ( ) const
virtual

The Br \((H\to W W^*)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to W W^*)\)

Definition at line 3662 of file StandardModel/src/StandardModel.cpp.

3663{
3664 return GammaHtoWWstar()/GammaHTot();
3665}
virtual const double GammaHtoWWstar() const
The in the Standard Model.

◆ BrHtoZga()

const double StandardModel::BrHtoZga ( ) const
virtual

The Br \((H\to Z \gamma)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to Z \gamma)\)

Definition at line 3667 of file StandardModel/src/StandardModel.cpp.

3668{
3669 return GammaHtoZga()/GammaHTot();
3670}
virtual const double GammaHtoZga() const
The in the Standard Model.

◆ BrHtoZZstar()

const double StandardModel::BrHtoZZstar ( ) const
virtual

The Br \((H\to Z Z^*)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to Z Z^*)\)

Definition at line 3657 of file StandardModel/src/StandardModel.cpp.

3658{
3659 return GammaHtoZZstar()/GammaHTot();
3660}
virtual const double GammaHtoZZstar() const
The in the Standard Model.

◆ BrW()

const double StandardModel::BrW ( const Particle  fi,
const Particle  fj 
) const
virtual

The branching ratio of the \(W\) boson decaying into a SM fermion pair, \(Br(W\to f_i f_j)\).

Returns
\(Br(W\to f_i f_j)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1289 of file StandardModel/src/StandardModel.cpp.

1290{
1291 double GammW = GammaW();
1292 double GammWij = GammaW(fi, fj);
1293
1294 return GammWij/GammW;
1295}
virtual const double GammaW() const
The total width of the boson, .

◆ c02()

const double StandardModel::c02 ( ) const

The square of the cosine of the weak mixing angle \(c_0^2\) defined without weak radiative corrections.

The quantity \(c_0^2\) is given by

\[ c_0^2 = 1 - s_0^2\,, \]

where \(s_0^2\) is defined in s02().

See [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(s_0^2\)

Definition at line 1020 of file StandardModel/src/StandardModel.cpp.

1021{
1022 return ( 1.0 - s02());
1023}
const double s02() const
The square of the sine of the weak mixing angle defined without weak radiative corrections.

◆ checkEWPOscheme()

bool StandardModel::checkEWPOscheme ( const std::string  scheme) const
inlineprotected

A method to check if a given scheme name in string form is valid.

Parameters
[in]schemescheme name for \(M_W\), \(\rho_Z^f\) or \(\kappa_Z^f\)
Returns
a boolean that is true if the scheme name is valid

Definition at line 3552 of file StandardModel.h.

3553 {
3554 if (scheme.compare("NORESUM") == 0
3555 || scheme.compare("OMSI") == 0
3556 || scheme.compare("INTERMEDIATE") == 0
3557 || scheme.compare("OMSII") == 0
3558 || scheme.compare("APPROXIMATEFORMULA") == 0)
3559 return true;
3560 else
3561 return false;
3562 }

◆ CheckFlags()

bool StandardModel::CheckFlags ( ) const
virtual

A method to check the sanity of the set of model flags.

Returns
a boolean that is true if the set of model flags is sane

Reimplemented from QCD.

Definition at line 553 of file StandardModel/src/StandardModel.cpp.

554{
555 return (QCD::CheckFlags());
556}
virtual bool CheckFlags() const
A method to check the sanity of the set of model flags.
Definition: QCD.cpp:517

◆ CheckParameters()

bool StandardModel::CheckParameters ( const std::map< std::string, double > &  DPars)
virtual

A method to check if all the mandatory parameters for StandardModel have been provided in model initialization.

Parameters
[in]DParsa map of the parameters that are being updated in the Monte Carlo run (including parameters that are varied and those that are held constant)
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in CMFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, NPDF2, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, HiggsChiral, HiggsKigen, NPEpsilons, NPEpsilons_pureNP, NPHiggs, NPSMEFTd6, NPSTU, NPSTUVWXY, NPSTUZbbbarLR, NPZbbbar, NPZbbbarLinearized, SigmaBR, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 370 of file StandardModel/src/StandardModel.cpp.

371{
372 for (int i = 0; i < NSMvars; i++) {
373 if (DPars.find(SMvars[i]) == DPars.end()) {
374 std::cout << "ERROR: missing mandatory SM parameter " << SMvars[i] << std::endl;
377 }
378 }
379 return (QCD::CheckParameters(DPars));
380}
std::map< std::string, double > DPars
Definition: Minimal.cpp:11
void addMissingModelParameter(const std::string &missingParameterName)
Definition: Model.h:250
void raiseMissingModelParameterCount()
Definition: Model.h:260
virtual bool CheckParameters(const std::map< std::string, double > &DPars)
A method to check if all the mandatory parameters for QCD have been provided in model initialization.
Definition: QCD.cpp:421
static std::string SMvars[NSMvars]
A string array containing the labels of the model parameters in StandardModel.
static const int NSMvars
The number of the model parameters in StandardModel.

◆ checkSMparamsForEWPO()

bool StandardModel::checkSMparamsForEWPO ( )

A method to check whether the parameters relevant to the EWPO are updated.

This function is used for the cashing methods implemented in the current class: DeltaAlphaLepton(), DeltaAlpha(), Mw_SM(), rhoZ_l_SM(), rhoZ_q_SM(), kappaZ_l_SM(), kappaZ_q_SM() and GammaW_SM(). When the values of the StandardModel parameters are updated in the Monte Carlo run and differ from those stored in the cache SMparamsForEWPO_cache, this function updates the cache, and returns false.

Returns
a boolean that is true if the parameters are not updated.
See also
NumSMParamsForEWPO

Definition at line 562 of file StandardModel/src/StandardModel.cpp.

563{
564 // 11 parameters in QCD:
565 // AlsMz, Mz, mup, mdown, mcharm, mstrange, mtop, mbottom,
566 // mut, mub, muc
567 // 21 parameters in StandardModel
568 // GF, ale, dAle5Mz, mHl,
569 // mneutrino_1, mneutrino_2, mneutrino_3, melectron, mmu, mtau,
570 // delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b, delGammaWlv, delGammaWqq,
571 // 3 flags in StandardModel
572 // FlagMw_cache, FlagRhoZ_cache, FlagKappaZ_cache
573
574 // Note: When modifying the array below, the constant NumSMParams has to
575 // be modified accordingly.
576 double SMparams[NumSMParamsForEWPO] = {
578 mHl, mtpole,
583 leptons[MU].getMass(),
585 quarks[UP].getMass(),
590 mut, mub, muc,
595 };
596
597 // check updated parameters
598 bool bNotUpdated = true;
599 for (int i = 0; i < NumSMParamsForEWPO; ++i) {
600 if (SMparamsForEWPO_cache[i] != SMparams[i]) {
601 SMparamsForEWPO_cache[i] = SMparams[i];
602 bNotUpdated &= false;
603 }
604 }
605
606 return bNotUpdated;
607}
@ UP
Definition: QCD.h:324
@ DOWN
Definition: QCD.h:325
@ STRANGE
Definition: QCD.h:327
double mtpole
The pole mass of the top quark.
Definition: QCD.h:1020
double SMparamsForEWPO_cache[NumSMParamsForEWPO]
double Mw_inp
The mass of the boson in GeV used as input for FlagMWinput = TRUE.
double SchemeToDouble(const std::string scheme) const
A method to convert a given scheme name in string form into a floating-point number with double preci...
static const int NumSMParamsForEWPO
The number of the SM parameters that are relevant to the EW precision observables.

◆ computeBrHto4f()

const double StandardModel::computeBrHto4f ( ) const
inline

The Br \((H\to 4f)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to 4f)\) in the Standard Model

Definition at line 2978 of file StandardModel.h.

2979 {
2980 return 2.406e-01; // Mh=125.1 GeV
2981 }

◆ computeBrHto4l2()

const double StandardModel::computeBrHto4l2 ( ) const
inline

The Br \((H\to 4l)\) \(l=e,\mu\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to 4l)\) \(l=e,\muu\) in the Standard Model

Definition at line 2945 of file StandardModel.h.

2946 {
2947 return 1.252e-04; // Mh=125.1 GeV
2948 }

◆ computeBrHto4l3()

const double StandardModel::computeBrHto4l3 ( ) const
inline

The Br \((H\to 4l)\) \(l=e,\mu,\tau\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to 4l)\) \(l=e,\mu,\tau\) in the Standard Model

Definition at line 2956 of file StandardModel.h.

2957 {
2958 return 2.771e-04; // Mh=125.1 GeV
2959 }

◆ computeBrHto4q()

const double StandardModel::computeBrHto4q ( ) const
inline

The Br \((H\to 4q)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to 4q)\) in the Standard Model

Definition at line 2967 of file StandardModel.h.

2968 {
2969 return 1.098e-01; // Mh=125.1 GeV
2970 }

◆ computeBrHto4v()

const double StandardModel::computeBrHto4v ( ) const
inline

The Br \((H\to 4\nu)\) in the Standard Model.

Returns
Br \((H\to 4\nu)\) in the Standard Model

Definition at line 2901 of file StandardModel.h.

2902 {
2903 return 1.06e-3;
2904 }

◆ computeBrHtobb()

const double StandardModel::computeBrHtobb ( ) const
inline

The Br \((H\to bb)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to bb)\) in the Standard Model

Definition at line 2888 of file StandardModel.h.

2889 {
2890 return 5.807e-1; // Mh=125.1 GeV
2891 //return 5.67e-1; // Mh=125.6 GeV
2892 }

◆ computeBrHtocc()

const double StandardModel::computeBrHtocc ( ) const
inline

The Br \((H\to cc)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to cc)\) in the Standard Model

Definition at line 2865 of file StandardModel.h.

2866 {
2867 return 2.883e-2; // Mh=125.1 GeV
2868 //return 2.86e-2; // Mh=125.6 GeV
2869 }

◆ computeBrHtoevmuv()

const double StandardModel::computeBrHtoevmuv ( ) const
inline

The Br \((H\to e \nu \mu \nu)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to e \nu \mu \nu)\) in the Standard Model

Definition at line 2912 of file StandardModel.h.

2913 {
2914 return 2.539e-03; // Mh=125.1 GeV
2915 }

◆ computeBrHtogaga()

const double StandardModel::computeBrHtogaga ( ) const
inline

The Br \((H\to\gamma\gamma)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to\gamma\gamma)\) in the Standard Model

Definition at line 2831 of file StandardModel.h.

2832 {
2833 return 2.27e-3; // Mh=125.1 GeV
2834 }

◆ computeBrHtogg()

const double StandardModel::computeBrHtogg ( ) const
inline

The Br \((H\to gg)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to gg)\)

Definition at line 2784 of file StandardModel.h.

2785 {
2786 return 8.179e-2; // Mh=125.1 GeV
2787 }

◆ computeBrHtollvv2()

const double StandardModel::computeBrHtollvv2 ( ) const
inline

The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu\) in the Standard Model

Definition at line 2923 of file StandardModel.h.

2924 {
2925 return 1.063e-02; // Mh=125.1 GeV
2926 }

◆ computeBrHtollvv3()

const double StandardModel::computeBrHtollvv3 ( ) const
inline

The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu,\tau\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu,\tau\) in the Standard Model

Definition at line 2934 of file StandardModel.h.

2935 {
2936 return 2.356e-02; // Mh=125.1 GeV
2937 }

◆ computeBrHtomumu()

const double StandardModel::computeBrHtomumu ( ) const
inline

The Br \((H\to \mu\mu)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to \mu\mu)\) in the Standard Model

Definition at line 2842 of file StandardModel.h.

2843 {
2844 return 2.17e-4; // Mh=125.1 GeV
2845 }

◆ computeBrHtoss()

const double StandardModel::computeBrHtoss ( ) const
inline

The Br \((H\to ss)\) in the Standard Model.

From Table 7 in http://cdsweb.cern.ch/record/2629412/files/ATLAS-CONF-2018-031.pdf

Returns
Br \((H\to ss)\) in the Standard Model

Definition at line 2877 of file StandardModel.h.

2878 {
2879 return 4.0e-4;
2880 }

◆ computeBrHtotautau()

const double StandardModel::computeBrHtotautau ( ) const
inline

The Br \((H\to \tau\tau)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to \tau\tau)\) in the Standard Model

Definition at line 2853 of file StandardModel.h.

2854 {
2855 return 6.256e-2; // Mh=125.1 GeV
2856 //return 6.22e-2; // Mh=125.6 GeV
2857 }

◆ computeBrHtoWW()

const double StandardModel::computeBrHtoWW ( ) const
inline

The Br \((H\to WW)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to WW)\) in the Standard Model

Definition at line 2795 of file StandardModel.h.

2796 {
2797 //return 2.23e-1; // Mh=125.5 GeV
2798 return 2.154e-1; // Mh=125.1 GeV
2799 }

◆ computeBrHtoZga()

const double StandardModel::computeBrHtoZga ( ) const
inline

The Br \((H\to Z\gamma)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to Z\gamma)\) in the Standard Model

Definition at line 2819 of file StandardModel.h.

2820 {
2821 return 1.541e-3; // Mh=125.1 GeV
2822 //return 1.59e-3; // Mh=125.6 GeV
2823 }

◆ computeBrHtoZZ()

const double StandardModel::computeBrHtoZZ ( ) const
inline

The Br \((H\to ZZ)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to ZZ)\) in the Standard Model

Definition at line 2807 of file StandardModel.h.

2808 {
2809 return 2.643e-2; // Mh=125.1 GeV
2810 //return 2.79e-2; // Mh=125.6 GeV
2811 }

◆ computeCKM()

void StandardModel::computeCKM ( )
protectedvirtual

The method to compute the CKM matrix.

Definition at line 382 of file StandardModel/src/StandardModel.cpp.

383{
384 if (requireCKM) {
385 if (FlagWolfenstein) {
387 Vus = myCKM.getV_us().abs();
388 Vcb = myCKM.getV_cb().abs();
389 Vub = myCKM.getV_ub().abs();
391 } else if (FlagUseVud) {
394 A = myCKM.getA();
395 rhob = myCKM.getRhoBar();
396 etab = myCKM.getEtaBar();
397 Vus = myCKM.getV_us().abs();
398 } else {
401 A = myCKM.getA();
402 rhob = myCKM.getRhoBar();
403 etab = myCKM.getEtaBar();
404 Vud = myCKM.getV_ud().abs();
405 }
406 }
407 myPMNS.computePMNS(s12, s13, s23, delta, alpha21, alpha31); // WARNING: This does not do anything since the input values are not set.
408}
void computeCKMwithWolfenstein(double Lambda_v, double A_v, double Rho_v, double Eta_v)
A set method to calculate the CKM matrix from Wolfenstein parameters.
Definition: CKM.cpp:13
const gslpp::complex getV_ud() const
A member for returning the value of the CKM element .
Definition: CKM.h:202
const gslpp::complex getV_us() const
A member for returning the value of the CKM element .
Definition: CKM.h:211
const double computeGamma() const
The CKM angle .
Definition: CKM.cpp:125
const gslpp::complex getV_cb() const
A member for returning the value of the CKM element .
Definition: CKM.h:247
const gslpp::complex getV_ub() const
A member for returning the value of the CKM element .
Definition: CKM.h:220
const double getA() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:97
void computeCKM(double Vus_v, double Vcb_v, double Vub_v, double gamma_v, bool useVud=false)
A set method to calculate the CKM matrix from CKM elements and .
Definition: CKM.cpp:86
const double getRhoBar() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:70
const double getLambda() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:88
const double getEtaBar() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:79
void computePMNS(double s12_v, double s13_v, double s23_v, double delta_v, double alpha21_v, double alpha31_v)
A set method to calculate the PMNS matrix from PMNS parameters.
Definition: PMNS.cpp:13
double Vub
used as an input for FlagWolfenstein = FALSE
double gamma
used as an input for FlagWolfenstein = FALSE
double Vud
used as an input for FlagWolfenstein = FALSE and FlagUseVud = TRUE
CKM myCKM
An object of type CKM.
double Vcb
used as an input for FlagWolfenstein = FALSE
double Vus
used as an input for FlagWolfenstein = FALSE

◆ ComputeDeltaR_rem()

void StandardModel::ComputeDeltaR_rem ( const double  Mw_i,
double  DeltaR_rem[orders_EW_size] 
) const

A method to collect \(\Delta r_{\mathrm{rem}}\) computed via subclasses.

This function collects \(\Delta r_{\mathrm{rem}}\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes.

Parameters
[in]Mw_ithe \(W\)-boson mass
[out]DeltaR_remArray of \(\Delta r_{\mathrm{rem}}\)

Definition at line 1161 of file StandardModel/src/StandardModel.cpp.

1163{
1164 if (flag_order[EW1])
1165 DeltaR_rem[EW1] = myOneLoopEW->DeltaR_rem(Mw_i);
1166 else
1167 DeltaR_rem[EW1] = 0.0;
1168 if (flag_order[EW1QCD1])
1169 DeltaR_rem[EW1QCD1] = myTwoLoopQCD->DeltaR_rem(Mw_i);
1170 else
1171 DeltaR_rem[EW1QCD1] = 0.0;
1172 if (flag_order[EW1QCD2])
1173 DeltaR_rem[EW1QCD2] = myThreeLoopQCD->DeltaR_rem(Mw_i);
1174 else
1175 DeltaR_rem[EW1QCD2] = 0.0;
1176 if (flag_order[EW2])
1177 DeltaR_rem[EW2] = myTwoLoopEW->DeltaR_rem(Mw_i);
1178 else
1179 DeltaR_rem[EW2] = 0.0;
1180 if (flag_order[EW2QCD1])
1181 DeltaR_rem[EW2QCD1] = myThreeLoopEW2QCD->DeltaR_rem(Mw_i);
1182 else
1183 DeltaR_rem[EW2QCD1] = 0.0;
1184 if (flag_order[EW3])
1185 DeltaR_rem[EW3] = myThreeLoopEW->DeltaR_rem(Mw_i);
1186 else
1187 DeltaR_rem[EW3] = 0.0;
1188}
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .

◆ ComputeDeltaRho()

void StandardModel::ComputeDeltaRho ( const double  Mw_i,
double  DeltaRho[orders_EW_size] 
) const

A method to collect \(\Delta\rho\) computed via subclasses.

This function collects \(\Delta\rho\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes.

Parameters
[in]Mw_ithe \(W\)-boson mass
[out]DeltaRhoArray of \(\Delta\rho\)

Definition at line 1132 of file StandardModel/src/StandardModel.cpp.

1134{
1135 if (flag_order[EW1])
1136 DeltaRho[EW1] = myOneLoopEW->DeltaRho(Mw_i);
1137 else
1138 DeltaRho[EW1] = 0.0;
1139 if (flag_order[EW1QCD1])
1140 DeltaRho[EW1QCD1] = myTwoLoopQCD->DeltaRho(Mw_i);
1141 else
1142 DeltaRho[EW1QCD1] = 0.0;
1143 if (flag_order[EW1QCD2])
1144 DeltaRho[EW1QCD2] = myThreeLoopQCD->DeltaRho(Mw_i);
1145 else
1146 DeltaRho[EW1QCD2] = 0.0;
1147 if (flag_order[EW2])
1148 DeltaRho[EW2] = myTwoLoopEW->DeltaRho(Mw_i);
1149 else
1150 DeltaRho[EW2] = 0.0;
1151 if (flag_order[EW2QCD1])
1152 DeltaRho[EW2QCD1] = myThreeLoopEW2QCD->DeltaRho(Mw_i);
1153 else
1154 DeltaRho[EW2QCD1] = 0.0;
1155 if (flag_order[EW3])
1156 DeltaRho[EW3] = myThreeLoopEW->DeltaRho(Mw_i);
1157 else
1158 DeltaRho[EW3] = 0.0;
1159}
double DeltaRho(const double Mw_i) const
Leading one-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading three-loop QCD contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading two-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading two-loop QCD contribution of to , denoted as .

◆ computeGammaHgaga_tt()

const double StandardModel::computeGammaHgaga_tt ( ) const
inline

The top loop contribution to \(H\to\gamma\gamma\) in the Standard Model.

Currently it returns the value of tab 40 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to\gamma\gamma\) (top loop contribution squared) in eV

Definition at line 3066 of file StandardModel.h.

3067 {
3068 return 662.84; // in eV for Mh=125 GeV
3069 //return 680.39; // in eV for Mh=126 GeV
3070 }

◆ computeGammaHgaga_tW()

const double StandardModel::computeGammaHgaga_tW ( ) const
inline

The mixed \(t-W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model.

Currently it returns the value of tab 40 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to\gamma\gamma\) (top W loop interference) in eV

Definition at line 3088 of file StandardModel.h.

3089 {
3090 return -6249.93; // in eV for Mh=125 GeV
3091 //return -6436.35; // in eV for Mh=126 GeV
3092 }

◆ computeGammaHgaga_WW()

const double StandardModel::computeGammaHgaga_WW ( ) const
inline

The \(W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model.

Currently it returns the value of tab 40 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to\gamma\gamma\) (W loop contribution squared) in eV

Definition at line 3077 of file StandardModel.h.

3078 {
3079 return 14731.86; // in eV for Mh=125 GeV
3080 //return 15221.98; // in eV for Mh=126 GeV
3081 }

◆ computeGammaHgg_bb()

const double StandardModel::computeGammaHgg_bb ( ) const
inline

The bottom loop contribution to \(H\to gg\) in the Standard Model.

Currently it returns the value of tab 39 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to gg\) (bottom loop contribution squared) in keV

Definition at line 3011 of file StandardModel.h.

3012 {
3013 return 3.96; // in keV for Mh=125 GeV
3014 //return 3.95; // in keV for Mh=126 GeV
3015 }

◆ computeGammaHgg_tb()

const double StandardModel::computeGammaHgg_tb ( ) const
inline

The top-bottom interference contribution to \(H\to gg\) in the Standard Model.

Currently it returns the value of tab 39 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to gg\) (top-bottom interference contribution) in keV

Definition at line 3022 of file StandardModel.h.

3023 {
3024 return -42.1; // in keV for Mh=125 GeV
3025 //return -42.7; // in keV for Mh=126 GeV
3026 }

◆ computeGammaHgg_tt()

const double StandardModel::computeGammaHgg_tt ( ) const
inline

The top loop contribution to \(H\to gg\) in the Standard Model.

Currently it returns the value of tab 39 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to gg\) (top loop contribution squared) in keV

Definition at line 3000 of file StandardModel.h.

3001 {
3002 return 380.8; // in keV for Mh=125 GeV
3003 //return 389.6; // in keV for Mh=126 GeV
3004 }

◆ computeGammaHTotal()

const double StandardModel::computeGammaHTotal ( ) const
inline

The Higgs total width in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
\(\Gamma_h\) in GeV in the Standard Model

Definition at line 2989 of file StandardModel.h.

2990 {
2991 return 4.101e-3; // Mh=125.1 GeV
2992 //return 4.15e-3; // Mh=125.6 GeV
2993 }

◆ computeGammaHZga_tt()

const double StandardModel::computeGammaHZga_tt ( ) const
inline

The top loop contribution to \(H\to Z\gamma\) in the Standard Model.

Currently it returns the value of tab 41 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to Z\gamma\) (top loop contribution squared) in eV

Definition at line 3033 of file StandardModel.h.

3034 {
3035 return 21.74; // in eV for Mh=125 GeV
3036 //return 23.51; // in eV for Mh=126 GeV
3037 }

◆ computeGammaHZga_tW()

const double StandardModel::computeGammaHZga_tW ( ) const
inline

The mixed \(t-W\) loop contribution to \(H\to Z\gamma\) in the Standard Model.

Currently it returns the value of tab 41 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to Z\gamma\) (top W loop interference) in eV

Definition at line 3055 of file StandardModel.h.

3056 {
3057 return -780.4; // in eV for Mh=125 GeV
3058 //return -848.1; // in eV for Mh=126 GeV
3059 }

◆ computeGammaHZga_WW()

const double StandardModel::computeGammaHZga_WW ( ) const
inline

The \(W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. Currently it returns the value of tab 41 in ref. [Heinemeyer:2013tqa].

Returns
Width of \(H\to Z\gamma\) (W loop contribution squared) in eV

Definition at line 3044 of file StandardModel.h.

3045 {
3046 return 7005.6; // in eV for Mh=125 GeV
3047 //return 7648.4; // in eV for Mh=126 GeV
3048 }

◆ computeSigmabbH()

const double StandardModel::computeSigmabbH ( const double  sqrt_s) const
inline

The bbH production cross section in the Standard Model.

Definition at line 2767 of file StandardModel.h.

2768 {
2769 if (sqrt_s == 13.0){
2770 return 0.4863; // in pb for Mh=125.09 GeV
2771 }
2772 else if (sqrt_s == 13.6) {
2773 return 0.566; // in pb for Mh=125.09 GeV (NLO+NNLLpart+ybyt matching)
2774 } else
2775 throw std::runtime_error("Bad argument in StandardModel::computeSigmabbH()");
2776 }

◆ computeSigmaggH()

const double StandardModel::computeSigmaggH ( const double  sqrt_s) const
inline

The ggH cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [Heinemeyer:2013tqa] and the updates in https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA for 7 and 8 TeV For the 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
ggH cross section in pb

Definition at line 2403 of file StandardModel.h.

2404 {
2405 if (sqrt_s == 7.0) {
2406 return 16.83; // in pb for Mh=125.1 GeV
2407 } else if (sqrt_s == 8.0) {
2408 return 21.40; // in pb for Mh=125.1 GeV
2409 } else if (sqrt_s == 13.0) {
2410 return 48.61; // in pb for Mh=125.09 GeV
2411 } else if (sqrt_s == 13.6) {
2412 return 52.17; // in pb for Mh=125.09 GeV
2413 } else if (sqrt_s == 14.0) {
2414 return 54.72; // in pb for Mh=125.09 GeV
2415 } else if (sqrt_s == 27.0) {
2416 return 146.65; // in pb for Mh=125.09 GeV
2417 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2418 return 740.3; // in pb for Mh=125. GeV
2419 } else if (sqrt_s == 1.96) {
2420 return 0.9493; // in pb for Mh=125 GeV
2421 } else
2422 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH()");
2423 }

◆ computeSigmaggH_bb()

const double StandardModel::computeSigmaggH_bb ( const double  sqrt_s) const
inline

The square of the bottom-quark contribution to the ggH cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
\(\sigma_{ggH}^{bb}\) in pb

Definition at line 2465 of file StandardModel.h.

2466 {
2467 if (sqrt_s == 7.0) {
2468 return 0.04; // in pb for Mh=125.09 GeV
2469 } else if (sqrt_s == 8.0) {
2470 return 0.05; // in pb for Mh=125.09 GeV
2471 } else if (sqrt_s == 13.0) {
2472 return 0.10; // in pb for Mh=125.09 GeV
2473 } else if (sqrt_s == 13.6) {
2474 return 0.106; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2475 } else if (sqrt_s == 14.0) {
2476 return 0.11; // in pb for Mh=125.09 GeV
2477 } else if (sqrt_s == 27.0) {
2478 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_bb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2479 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2480 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_bb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2481 } else
2482 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_bb()");
2483 }
const double computeSigmaggH(const double sqrt_s) const
The ggH cross section in the Standard Model.
const double computeSigmaggH_bb(const double sqrt_s) const
The square of the bottom-quark contribution to the ggH cross section in the Standard Model.

◆ computeSigmaggH_tb()

const double StandardModel::computeSigmaggH_tb ( const double  sqrt_s) const
inline

The top-bottom interference contribution to the ggH cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
\(\sigma_{ggH}^{tb}\) in pb

Definition at line 2495 of file StandardModel.h.

2496 {
2497 if (sqrt_s == 7.0) {
2498 return -0.66; // in pb for Mh=125.09 GeV
2499 } else if (sqrt_s == 8.0) {
2500 return -0.82; // in pb for Mh=125.09 GeV
2501 } else if (sqrt_s == 13.0) {
2502 return -1.73; // in pb for Mh=125.09 GeV
2503 } else if (sqrt_s == 13.6) {
2504 return -1.844; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2505 } else if (sqrt_s == 14.0) {
2506 return -1.92; // in pb for Mh=125.09 GeV
2507 } else if (sqrt_s == 27.0) {
2508 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2509 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2510 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2511 } else
2512 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_tb()");
2513 }
const double computeSigmaggH_tb(const double sqrt_s) const
The top-bottom interference contribution to the ggH cross section in the Standard Model.

◆ computeSigmaggH_tt()

const double StandardModel::computeSigmaggH_tt ( const double  sqrt_s) const
inline

The square of the top-quark contribution to the ggH cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
\(\sigma_{ggH}^{tt}\) in pb

Definition at line 2435 of file StandardModel.h.

2436 {
2437 if (sqrt_s == 7.0) {
2438 return 16.69; // in pb for Mh=125.09 GeV
2439 } else if (sqrt_s == 8.0) {
2440 return 21.20; // in pb for Mh=125.09 GeV
2441 } else if (sqrt_s == 13.0) {
2442 return 47.94; // in pb for Mh=125.09 GeV
2443 } else if (sqrt_s == 13.6) {
2444 return 51.534; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2445 } else if (sqrt_s == 14.0) {
2446 return 53.93; // in pb for Mh=125.09 GeV
2447 } else if (sqrt_s == 27.0) {
2448 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tt(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2449 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2450 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tt(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2451 } else
2452 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_tt()");
2453 }
const double computeSigmaggH_tt(const double sqrt_s) const
The square of the top-quark contribution to the ggH cross section in the Standard Model.

◆ computeSigmatHq()

const double StandardModel::computeSigmatHq ( const double  sqrt_s) const
inline

The tHq production cross section in the Standard Model.

For the 13 TeV values we use the official numbers a la CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageAt13TeV

Definition at line 2748 of file StandardModel.h.

2749 {
2750 if (sqrt_s == 13.0) {
2751 return 0.07426; // in pb for Mh=125.09 GeV
2752 } else
2753 throw std::runtime_error("Bad argument in StandardModel::computeSigmatHq()");
2754 }

◆ computeSigmattH()

const double StandardModel::computeSigmattH ( const double  sqrt_s) const
inline

The ttH production cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [Heinemeyer:2013tqa] . For the 13 TeV values we use the official numbers a la CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageAt13TeV https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageAt14TeV For the 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
ttH production cross section in pb

Definition at line 2718 of file StandardModel.h.

2719 {
2720 if (sqrt_s == 7.0) {
2721 return 0.0861; // in pb for Mh=125.1 GeV
2722 //return 0.0851; // in pb for Mh=125.6 GeV
2723 } else if (sqrt_s == 8.0) {
2724 return 0.129; // in pb for Mh=125.1 GeV
2725 //return 0.1274; // in pb for Mh=125.6 GeV
2726 } else if (sqrt_s == 13.0) {
2727 return 0.5060; // in pb for Mh=125.1 GeV
2728 } else if (sqrt_s == 13.6) {
2729 return 0.5688; // in pb for Mh=125.09 GeV
2730 } else if (sqrt_s == 14.0) {
2731 return 0.6128; // in pb for Mh=125.09 GeV
2732 } else if (sqrt_s == 27.0) {
2733 return 2.86; // in pb for Mh=125.09 GeV
2734 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2735 return 37.9; // in pb for Mh=125. GeV
2736 } else if (sqrt_s == 1.96) {
2737 return 0.0043; // in pb for Mh=125 GeV
2738 } else
2739 throw std::runtime_error("Bad argument in StandardModel::computeSigmattH()");
2740 }

◆ computeSigmaVBF()

const double StandardModel::computeSigmaVBF ( const double  sqrt_s) const
inline

The VBF cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [Heinemeyer:2013tqa] . For the 7, 8, 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
VBF cross section in pb

Definition at line 2528 of file StandardModel.h.

2529 {
2530 if (sqrt_s == 7.0) {
2531 return 1.241; // in pb for Mh=125.09 GeV
2532 } else if (sqrt_s == 8.0) {
2533 return 1.601; // in pb for Mh=125.09 GeV
2534 } else if (sqrt_s == 13.0) {
2535 return 3.766; // in pb for Mh=125.09 GeV
2536 } else if (sqrt_s == 13.6) {
2537 return 4.075; // in pb for Mh=125.09 GeV
2538 } else if (sqrt_s == 14.0) {
2539 return 4.260; // in pb for Mh=125.09 GeV
2540 } else if (sqrt_s == 27.0) {
2541 return 11.838; // in pb for Mh=125.09 GeV
2542 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2543 return 82.0; // in pb for Mh=125. GeV
2544 } else if (sqrt_s == 1.96) {
2545 return 0.0653; // in pb for Mh=125 GeV
2546 } else
2547 throw std::runtime_error("Bad argument in StandardModel::computeSigmaVBF()");
2548 }

◆ computeSigmaWF()

const double StandardModel::computeSigmaWF ( const double  sqrt_s) const
inline

The W fusion contribution \(\sigma_{WF}\) to higgs-production cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
W fusion contribution \(\sigma_{WF}\) to cross section in pb

Definition at line 2561 of file StandardModel.h.

2562 {
2563 if (sqrt_s == 7.0) {
2564 return 0.946; // in pb for Mh=125 GeV
2565 } else if (sqrt_s == 8.0) {
2566 return 1.220; // in pb for Mh=125 GeV
2567 } else if (sqrt_s == 13.0) {
2568 return 2.882; // in pb for Mh=125 GeV
2569 } else if (sqrt_s == 13.6) {
2570 return 3.1088; // in pb for Mh=125 GeV (interpolation between 13 and 14 TeV)
2571 } else if (sqrt_s == 14.0) {
2572 return 3.260; // in pb for Mh=125 GeV
2573 } else if (sqrt_s == 27.0) {
2574 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaWF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2575 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2576 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaWF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2577 } else if (sqrt_s == 1.96) {
2578 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(7.) * computeSigmaWF(7.); // in the absence of individual cross sections for TeVatron we rescale the LHC ones
2579 } else
2580 throw std::runtime_error("Bad argument in StandardModel::computeSigmaWF()");
2581 }
const double computeSigmaVBF(const double sqrt_s) const
The VBF cross section in the Standard Model.
const double computeSigmaWF(const double sqrt_s) const
The W fusion contribution to higgs-production cross section in the Standard Model.

◆ computeSigmaWH()

const double StandardModel::computeSigmaWH ( const double  sqrt_s) const
inline

The WH production cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [Heinemeyer:2013tqa] . For the 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
WH production cross section in pb

Definition at line 2641 of file StandardModel.h.

2642 {
2643 if (sqrt_s == 7.0) {
2644 return 0.577; // in pb for Mh=125.1 GeV
2645 //return 0.5688; // in pb for Mh=125.6 GeV
2646 } else if (sqrt_s == 8.0) {
2647 return 0.7027; // in pb for Mh=125.1 GeV
2648 //return 0.6931; // in pb for Mh=125.6 GeV
2649 } else if (sqrt_s == 13.0) {
2650 return 1.358; // in pb for Mh=125.09 GeV
2651 } else if (sqrt_s == 13.6) {
2652 return 1.453; // in pb for Mh=125.09 GeV
2653 } else if (sqrt_s == 14.0) {
2654 return 1.498; // in pb for Mh=125.09 GeV
2655 } else if (sqrt_s == 27.0) {
2656 return 3.397; // in pb for Mh=125.09 GeV
2657 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2658 return 15.9; // in pb for Mh=125. GeV
2659 } else if (sqrt_s == 1.96) {
2660 return 0.1295; // in pb for Mh=125 GeV
2661 } else
2662 throw std::runtime_error("Bad argument in StandardModel::computeSigmaWH()");
2663 }

◆ computeSigmaZF()

const double StandardModel::computeSigmaZF ( const double  sqrt_s) const
inline

The Z fusion contribution \(\sigma_{ZF}\) to higgs-production cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
W fusion contribution \(\sigma_{ZF}\) to cross section in pb

Definition at line 2594 of file StandardModel.h.

2595 {
2596 if (sqrt_s == 7.0) {
2597 return 0.333; // in pb for Mh=125 GeV
2598 } else if (sqrt_s == 8.0) {
2599 return 0.432; // in pb for Mh=125 GeV
2600 } else if (sqrt_s == 13.0) {
2601 return 1.049; // in pb for Mh=125 GeV
2602 } else if (sqrt_s == 13.6) {
2603 return 1.1342; // in pb for Mh=125 GeV (interpolation between 13 and 14 TeV)
2604 } else if (sqrt_s == 14.0) {
2605 return 1.191; // in pb for Mh=125 GeV
2606 } else if (sqrt_s == 27.0) {
2607 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaZF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2608 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2609 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaZF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2610 } else if (sqrt_s == 1.96) {
2611 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(7.) * computeSigmaZF(7.); // in the absence of individual cross sections for TeVatron we rescale the LHC ones
2612 } else
2613 throw std::runtime_error("Bad argument in StandardModel::computeSigmaZF()");
2614 }
const double computeSigmaZF(const double sqrt_s) const
The Z fusion contribution to higgs-production cross section in the Standard Model.

◆ computeSigmaZH()

const double StandardModel::computeSigmaZH ( const double  sqrt_s) const
inline

The ZH production cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [Heinemeyer:2013tqa] . For the 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
ZH production cross section in pb

Definition at line 2678 of file StandardModel.h.

2679 {
2680 if (sqrt_s == 7.0) {
2681 return 0.3341; // in pb for Mh=125.1 GeV
2682 //return 0.3299; // in pb for Mh=125.6 GeV
2683 } else if (sqrt_s == 8.0) {
2684 return 0.4142; // in pb for Mh=125.1 GeV
2685 //return 0.4091; // in pb for Mh=125.6 GeV
2686 } else if (sqrt_s == 13.0) {
2687 return 0.880; // in pb for Mh=125.09 GeV
2688 } else if (sqrt_s == 13.6) {
2689 return 0.9422; // in pb for Mh=125.09 GeV
2690 } else if (sqrt_s == 14.0) {
2691 return 0.981; // in pb for Mh=125.09 GeV
2692 } else if (sqrt_s == 27.0) {
2693 return 2.463; // in pb for Mh=125.09 GeV
2694 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2695 return 11.26; // in pb for Mh=125. GeV
2696 } else if (sqrt_s == 1.96) {
2697 return 0.0785; // in pb for Mh=125 GeV
2698 } else
2699 throw std::runtime_error("Bad argument in StandardModel::computeSigmaZH()");
2700 }

◆ computeSigmaZWF()

const double StandardModel::computeSigmaZWF ( const double  sqrt_s) const
inline

The Z W interference fusion contribution \(\sigma_{ZWF}\) to higgs-production cross section in the Standard Model.

Negligible (0.1%) in the Standard model.

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
Z W interference fusion contribution \(\sigma_{ZWF}\) to cross section in pb

Definition at line 2623 of file StandardModel.h.

2624 {
2625 return 0.;
2626 }

◆ computeYukawas()

void StandardModel::computeYukawas ( )
protectedvirtual

The method to compute the Yukawas matrix.

Reimplemented in SUSY.

Definition at line 416 of file StandardModel/src/StandardModel.cpp.

417{
418 if (requireYu || requireCKM) {
419 Yu.reset();
420 for (int i = 0; i < 3; i++) {
421 Yu.assign(i, i, this->getmq(quark(UP + 2 * i), v()/ sqrt(2.))/ v() * sqrt(2.));
422// std::cout << quarks[UP + 2 * i].getName() << " mass at EW scale is " << this->getmq(quark(UP + 2 * i), v() / sqrt(2.)) << std::endl;
423 }
424// std::cout << "(top MSbar mass is " << this->Mp2Mbar(this->getMtpole()) << ")" << std::endl;
425 Yu = Yu * myCKM.getCKM();
426 }
427 if (requireYd) {
428 Yd.reset();
429 for (int i = 0; i < 3; i++) {
430 Yd.assign(i, i, this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) / v() * sqrt(2.));
431// std::cout << quarks[DOWN + 2 * i].getName() << " mass at " << v() / sqrt(2) << " is " << this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) << std::endl;
432 }
433 }
434 if (requireYe) {
435 Ye = gslpp::matrix<gslpp::complex>::Id(3);
436 for (int i = 0; i < 3; i++)
437 Ye.assign(i, i, this->leptons[ELECTRON + 2 * i].getMass() / v() * sqrt(2.));
438 }
439 if (requireYn) {
440 Yn = gslpp::matrix<gslpp::complex>::Id(3);
441 for (int i = 0; i < 3; i++)
442 Yn.assign(i, i, this->leptons[NEUTRINO_1 + 2 * i].getMass() / v() * sqrt(2.));
443 Yn = Yn * myPMNS.getPMNS().hconjugate();
444 }
445}
const gslpp::matrix< gslpp::complex > getCKM() const
A member for returning the CKM matrix.
Definition: CKM.h:59
gslpp::matrix< gslpp::complex > getPMNS() const
A member for returning the PMNS matrix.
Definition: PMNS.h:42
bool requireYu
Switch for generating the Yukawa couplings to the up-type quarks.
Definition: QCD.h:1012
quark
An enum type for quarks.
Definition: QCD.h:323
bool requireYd
Switch for generating the Yukawa couplings to the down-type quarks.
Definition: QCD.h:1013
virtual const double getmq(const QCD::quark q, const double mu) const
The MSbar running quark mass computed at NLO.

◆ cW2() [1/2]

const double StandardModel::cW2 ( ) const
virtual

Definition at line 1087 of file StandardModel/src/StandardModel.cpp.

1088{
1089 return ( cW2(Mw()));
1090// return (1.0 - 0.2312); // FOR HEFFDF1 TEST
1091}

◆ cW2() [2/2]

const double StandardModel::cW2 ( const double  Mw_i) const
virtual

The square of the cosine of the weak mixing angle in the on-shell scheme, denoted as \(c_W^2\).

\[ c_W^2=\cos^2{\theta_W}=\frac{M_W^2}{M_Z^2}. \]

Returns
\(c_W^2\)

Definition at line 1082 of file StandardModel/src/StandardModel.cpp.

1083{
1084 return ( Mw_i * Mw_i / Mz / Mz);
1085}

◆ Dalpha5hMz()

const double StandardModel::Dalpha5hMz ( ) const
virtual

The 5-quark contribution to the running of the em constant to the \(Z\) pole. \(\Delta\alpha_{had}^{(5)}(M_Z)\).

Depending on the flag MWinput this is given by the input parameter dAle5Mz (MWinput=false) or it is computed from Mw (MWinput=true)

Returns
\(\Delta\alpha_{had}^{(5)}(M_Z)\)

Definition at line 1074 of file StandardModel/src/StandardModel.cpp.

1075{
1076 if (FlagMWinput){
1078 } else
1079 return dAle5Mz;
1080}
double dAlpha5hMw() const
The value of obtained from the -boson mass, using the full two-loop EW corrections.

◆ Delta_EWQCD()

double StandardModel::Delta_EWQCD ( const QCD::quark  q) const
protected

The non-factorizable EW-QCD corrections to the partial widths for \(Z\to q\bar{q}\), denoted as \(\Delta_{\mathrm{EW/QCD}}\).

See [Czarnecki:1996ei] and [Harlander:1997zb].

Parameters
[in]qname of a quark (see QCD::quark)
Returns
\(\Delta_{\mathrm{EW/QCD}}\) in GeV

Definition at line 2139 of file StandardModel/src/StandardModel.cpp.

2140{
2141 switch (q) {
2142 case QCD::UP:
2143 case QCD::CHARM:
2144 return ( -0.000113);
2145 case QCD::TOP:
2146 return ( 0.0);
2147 case QCD::DOWN:
2148 case QCD::STRANGE:
2149 return ( -0.000160);
2150 case QCD::BOTTOM:
2151 return ( -0.000040);
2152 default:
2153 throw std::runtime_error("Error in StandardModel::Delta_EWQCD");
2154 }
2155}
@ TOP
Definition: QCD.h:328

◆ DeltaAlpha()

const double StandardModel::DeltaAlpha ( ) const

The total corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha(M_Z^2)\).

\[ \Delta\alpha(M_Z^2) = \Delta\alpha_{\rm lept}(M_Z^2) + \Delta\alpha_{\rm had}^{(5)}(M_Z^2) + \Delta\alpha_{\rm top}(M_Z^2)\,. \]

Returns
\(\Delta\alpha(M_Z^2)\)

Definition at line 932 of file StandardModel/src/StandardModel.cpp.

933{
936 return DeltaAlpha_cache;
937
938 double Mz2 = Mz*Mz;
940 useDeltaAlpha_cache = true;
941 return DeltaAlpha_cache;
942}
const double DeltaAlphaTop(const double s) const
Top-quark contribution to the electromagnetic coupling , denoted as .
const double DeltaAlphaL5q() const
The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling at...

◆ DeltaAlphaL5q()

const double StandardModel::DeltaAlphaL5q ( ) const

The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha^{\ell+5q}(M_Z^2)\).

\[ \Delta\alpha^{\ell+5q}(M_Z^2) = \Delta\alpha_{\rm lept}(M_Z^2) + \Delta\alpha_{\rm had}^{(5)}(M_Z^2)\,. \]

Returns
\(\Delta\alpha^{\ell+5q}(M_Z^2)\)

Definition at line 907 of file StandardModel/src/StandardModel.cpp.

908{
909 double Mz2 = Mz*Mz;
910 return (DeltaAlphaLepton(Mz2) + dAl5hMz);
911}
double dAl5hMz
The five-flavour hadronic contribution to the electromagnetic coupling, . (Non-input parameter)
const double DeltaAlphaLepton(const double s) const
Leptonic contribution to the electromagnetic coupling , denoted as .

◆ DeltaAlphaLepton()

const double StandardModel::DeltaAlphaLepton ( const double  s) const

Leptonic contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{lept}}(s)\).

Parameters
[in]sinvariant mass squared
Returns
\(\Delta\alpha_{\mathrm{lept}}(s)\)

Definition at line 879 of file StandardModel/src/StandardModel.cpp.

880{
881 if (s == Mz * Mz)
885
886 double DeltaAlphaL = 0.0;
887 if (flag_order[EW1])
888 DeltaAlphaL += myOneLoopEW->DeltaAlpha_l(s);
889 if (flag_order[EW1QCD1])
890 DeltaAlphaL += myTwoLoopQCD->DeltaAlpha_l(s);
891 if (flag_order[EW1QCD2])
892 DeltaAlphaL += myThreeLoopQCD->DeltaAlpha_l(s);
893 if (flag_order[EW2])
894 DeltaAlphaL += myTwoLoopEW->DeltaAlpha_l(s);
895 if (flag_order[EW2QCD1])
896 DeltaAlphaL += myThreeLoopEW2QCD->DeltaAlpha_l(s);
897 if (flag_order[EW3])
898 DeltaAlphaL += myThreeLoopEW->DeltaAlpha_l(s);
899
900 if (s == Mz * Mz) {
901 DeltaAlphaLepton_cache = DeltaAlphaL;
903 }
904 return DeltaAlphaL;
905}
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .

◆ DeltaAlphaTop()

const double StandardModel::DeltaAlphaTop ( const double  s) const

Top-quark contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{top}}(s)\).

Parameters
[in]sinvariant mass squared
Returns
\(\Delta\alpha_{\mathrm{top}}(s)\)

Definition at line 913 of file StandardModel/src/StandardModel.cpp.

914{
915 double DeltaAlpha = 0.0;
916 if (flag_order[EW1])
918 if (flag_order[EW1QCD1])
920 if (flag_order[EW1QCD2])
922 if (flag_order[EW2])
924 if (flag_order[EW2QCD1])
926 if (flag_order[EW3])
928
929 return DeltaAlpha;
930}
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .

◆ deltaKappaZ_f()

const gslpp::complex StandardModel::deltaKappaZ_f ( const Particle  f) const
virtual

Flavour non-universal vertex corrections to \(\kappa_Z^l\), denoted by \(\Delta\kappa_Z^l\).

The non-universal contribution \(\Delta\kappa_Z^l\) is given by

\[ \Delta \kappa_Z^l = \kappa_Z^l - \kappa_Z^e = \frac{\alpha}{4\pi s_W^2} \left( \frac{\delta_l^2-\delta_e^2}{4c_W^2}\,\mathcal{F}_Z(M_Z^2) -u_l+u_e\right), \]

where \(u_l\) and \(\delta_l\) are defined as

\[ u_l = \frac{3v_l^2+a_l^2}{4c_W^2}\mathcal{F}_Z(M_Z^2) + \mathcal{F}_W^l(M_Z^2)\,, \qquad \delta_l = v_l - a_l \]

with the tree-level vector and axial-vector couplings \(v_l = I_3^l - 2Q_l s_W^2\) and \(a_l = I_3^l\), and the form factors \(\mathcal{F}_Z\) and \(\mathcal{F}_W^l\).

See [Ciuchini:2013pca] and references therein.

Parameters
[in]fa lepton or quark
Returns
\(\Delta\kappa_Z^l\)

Definition at line 1770 of file StandardModel/src/StandardModel.cpp.

1771{
1772 Particle p1 = f, pe = leptons[ELECTRON];
1773
1774 if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1775
1776 /* In the case of BOTTOM, the top contribution has to be subtracted.
1777 * The remaining contribution is the same as that for DOWN and STRANGE. */
1778 if (f.is("BOTTOM")) p1 = quarks[DOWN];
1779
1780 double myMw = Mw();
1781 double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1782 gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1783 + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1784 + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1785 double deltal = myEWSMcache->delta_f(pe, myMw);
1786 gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1787 + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1788 + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1789 double deltaf = myEWSMcache->delta_f(p1, myMw);
1790
1791 gslpp::complex dKappa = (deltaf * deltaf - deltal * deltal) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1792 - uf + ul;
1793 dKappa *= ale / 4.0 / M_PI / sW2;
1794 return dKappa;
1795}
gslpp::complex FZ(const double s, const double Mw_i) const
The unified form factor .
gslpp::complex FW(const double s, const Particle f, const double Mw_i) const
The unified form factor for .
double a_f(const Particle f) const
The tree-level axial-vector coupling for , denoted as .
Definition: EWSMcache.h:301
double v_f(const Particle f, const double Mw_i) const
The tree-level vector coupling for , denoted as .
Definition: EWSMcache.h:290
double delta_f(const Particle f, const double Mw_i) const
.
Definition: EWSMcache.h:323
bool is(std::string name_i) const
Definition: Particle.cpp:23

◆ DeltaR()

const double StandardModel::DeltaR ( ) const
virtual

The SM prediction for \(\Delta r\) derived from that for the \(W\) boson mass.

If the model flag Mw of StandardModel is set to NORESUM or APPROXIMATEFORMULA, the quantity \(\Delta r\) is computed by using the following relation:

\[ s_W^2 M_W^2 = \frac{\pi\,\alpha}{\sqrt{2}G_\mu}(1+\Delta r)\,. \]

Otherwise, the following relation is employed instead:

\[ s_W^2 M_W^2 = \frac{\pi\,\alpha}{\sqrt{2}G_\mu(1-\Delta r)}\,, \]

where the resummation for \(\Delta r\) is considered.

Returns
\(\Delta r_{\mathrm{SM}}\)
See also
The corresponding quantity in the complex-pole/fixed-width scheme (instead of the experimental/running-widthr scheme) is defined in DeltaRbar_SM().

Definition at line 1118 of file StandardModel/src/StandardModel.cpp.

1119{
1120 /* in the experimental/running-width scheme */
1121 double myMw = Mw();
1122 double sW2 = 1.0 - myMw * myMw / Mz / Mz;
1123 double tmp = sqrt(2.0) * GF * sW2 * myMw * myMw / M_PI / ale;
1124 if (FlagMw.compare("NORESUM") == 0
1125 || FlagMw.compare("APPROXIMATEFORMULA") == 0) {
1126 return (tmp - 1.0);
1127 } else {
1128 return (1.0 - 1.0 / tmp);
1129 }
1130}

◆ DeltaRbar()

const double StandardModel::DeltaRbar ( ) const
virtual

The SM prediction for \(\Delta \overline{r}\) derived from that for the \(W\)-boson mass.

The quantity \(\Delta \overline{r}\) is computed by using the following relation:

\[ \overline{s}_W^2 \overline{M}_W^2 = \frac{\pi\,\alpha}{\sqrt{2}G_\mu}(1+\Delta \overline{r})\,, \]

where \(\overline{M}_W\) and \(\overline{s}_W\) are the \(W\)-boson mass and the sine of the weak mixing angle in the complex-pole/fixed-width scheme [Bardin:1988xt].

Returns
\(\Delta \overline{r}_{\mathrm{SM}}\)
See also
DeltaR_SM(), defining the corresponding quantity in the experimental/running-width scheme.

Definition at line 1228 of file StandardModel/src/StandardModel.cpp.

1229{
1230 double Mwbar_SM = MwbarFromMw(Mw());
1231 double sW2bar = 1.0 - Mwbar_SM * Mwbar_SM / Mzbar() / Mzbar();
1232 double tmp = sqrt(2.0) * GF * sW2bar * Mwbar_SM * Mwbar_SM / M_PI / ale;
1233
1234 return (tmp - 1.0);
1235}
double Mzbar() const
The -boson mass in the complex-pole/fixed-width scheme.
const double MwbarFromMw(const double Mw) const
A method to convert the -boson mass in the experimental/running-width scheme to that in the complex-p...

◆ deltaRhoZ_f()

const gslpp::complex StandardModel::deltaRhoZ_f ( const Particle  f) const
virtual

Flavour non-universal vertex corrections to \(\rho_Z^l\), denoted by \(\Delta\rho_Z^l\).

The non-universal contribution \(\Delta\rho_Z^l\) is given by

\[ \Delta \rho_Z^l = \rho_Z^l - \rho_Z^e = \frac{\alpha}{2\pi s_W^2}\left(u_l - u_e\right), \]

where \(u_l\) is defined as

\[ u_l = \frac{3v_l^2+a_l^2}{4c_W^2}\mathcal{F}_Z(M_Z^2) + \mathcal{F}_W^l(M_Z^2) \]

with the tree-level vector and axial-vector couplings \(v_l = I_3^l - 2Q_l s_W^2\) and \(a_l = I_3^l\) and the form factors, \(\mathcal{F}_Z\) and \(\mathcal{F}_W^l\).

See [Ciuchini:2013pca] and references therein.

Parameters
[in]fa lepton or quark
Returns
\(\Delta\rho_Z^l\)

Definition at line 1745 of file StandardModel/src/StandardModel.cpp.

1746{
1747 Particle p1 = f, pe = leptons[ELECTRON];
1748
1749 if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1750
1751 /* In the case of BOTTOM, the top contribution has to be subtracted.
1752 * The remaining contribution is the same as that for DOWN and STRANGE. */
1753 if (f.is("BOTTOM")) p1 = quarks[DOWN];
1754
1755 double myMw = Mw();
1756 double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1757
1758 gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1759 + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1760 + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1761 gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1762 + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1763 + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1764
1765 gslpp::complex dRho = 2.0 * (uf - ul);
1766 dRho *= ale / 4.0 / M_PI / sW2;
1767 return dRho;
1768}

◆ eeffAFBbottom()

virtual const double StandardModel::eeffAFBbottom ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3289 of file StandardModel.h.

3290 {
3291 return ( ( eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 1.0) );
3292 }
virtual const double eeffsigma(const Particle f, const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const

◆ eeffAFBcharm()

virtual const double StandardModel::eeffAFBcharm ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3285 of file StandardModel.h.

3286 {
3287 return ( ( eeffsigma(quarks[CHARM], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 1.0) );
3288 }

◆ eeffAFBe()

virtual const double StandardModel::eeffAFBe ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3259 of file StandardModel.h.

3260 {
3261 double cosmin = -0.90; // As in LEP2
3262 double cosmax = 0.90; // As in LEP2
3263
3264 return (( eeffsigmaEbin(pol_e, pol_p, s, 0.0 , cosmax) - eeffsigmaEbin(pol_e, pol_p, s, cosmin, 0.0) ) / eeffsigmaEbin(pol_e, pol_p, s, cosmin, cosmax));
3265 }
const double eeffsigmaEbin(const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const

◆ eeffAFBetsub()

virtual const double StandardModel::eeffAFBetsub ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3266 of file StandardModel.h.

3267 {
3268 double cosmin = -0.90; // As in LEP2
3269 double cosmax = 0.90; // As in LEP2
3270
3271 return ( ( eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, 0.0 , cosmax) - eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, cosmin, 0.0) ) / eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, cosmin, cosmax) );
3272 }

◆ eeffAFBmu()

virtual const double StandardModel::eeffAFBmu ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3273 of file StandardModel.h.

3274 {
3275 return ( ( eeffsigma(leptons[MU], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(leptons[MU], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(leptons[MU], pol_e, pol_p, s, -1.0, 1.0) );
3276 }

◆ eeffAFBstrange()

virtual const double StandardModel::eeffAFBstrange ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3281 of file StandardModel.h.

3282 {
3283 return ( ( eeffsigma(quarks[STRANGE], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 1.0) );
3284 }

◆ eeffAFBtau()

virtual const double StandardModel::eeffAFBtau ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3277 of file StandardModel.h.

3278 {
3279 return ( ( eeffsigma(leptons[TAU], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(leptons[TAU], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(leptons[TAU], pol_e, pol_p, s, -1.0, 1.0) );
3280 }

◆ eeffRbottom()

virtual const double StandardModel::eeffRbottom ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3252 of file StandardModel.h.

3253 {
3254 return ( eeffsigmaBottom(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3255 }
virtual const double eeffsigmaBottom(const double pol_e, const double pol_p, const double s) const
virtual const double eeffsigmaHadron(const double pol_e, const double pol_p, const double s) const

◆ eeffRcharm()

virtual const double StandardModel::eeffRcharm ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3248 of file StandardModel.h.

3249 {
3250 return ( eeffsigmaCharm(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3251 }
virtual const double eeffsigmaCharm(const double pol_e, const double pol_p, const double s) const

◆ eeffRelectron()

virtual const double StandardModel::eeffRelectron ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3228 of file StandardModel.h.

3229 {
3230 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaE(pol_e, pol_p, s) );
3231 }
virtual const double eeffsigmaE(const double pol_e, const double pol_p, const double s) const

◆ eeffRelectrontsub()

virtual const double StandardModel::eeffRelectrontsub ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3232 of file StandardModel.h.

3233 {
3234 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaEtsub(pol_e, pol_p, s) );
3235 }
virtual const double eeffsigmaEtsub(const double pol_e, const double pol_p, const double s) const

◆ eeffRmuon()

virtual const double StandardModel::eeffRmuon ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3236 of file StandardModel.h.

3237 {
3238 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaMu(pol_e, pol_p, s) );
3239 }
virtual const double eeffsigmaMu(const double pol_e, const double pol_p, const double s) const

◆ eeffRstrange()

virtual const double StandardModel::eeffRstrange ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3244 of file StandardModel.h.

3245 {
3246 return ( eeffsigmaStrange(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3247 }
virtual const double eeffsigmaStrange(const double pol_e, const double pol_p, const double s) const

◆ eeffRtau()

virtual const double StandardModel::eeffRtau ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3240 of file StandardModel.h.

3241 {
3242 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaTau(pol_e, pol_p, s) );
3243 }
virtual const double eeffsigmaTau(const double pol_e, const double pol_p, const double s) const

◆ eeffsigma()

const double StandardModel::eeffsigma ( const Particle  f,
const double  pol_e,
const double  pol_p,
const double  s,
const double  cosmin,
const double  cosmax 
) const
virtual

Reimplemented in NPbase.

Definition at line 4054 of file StandardModel/src/StandardModel.cpp.

4054 {
4055 // Only valid for f=/=e (MLL2, MRR2 do not depend on t for f=/=e. Simply enter t=1 as argument)
4056 // For f=e this corresponds to t-subtracted definition from LEP
4057 double sumM2, sigma;
4058 double tdumm = 1.;
4059 double topb = 0.3894e+9;
4060
4061 //double cosmin = -1.0;
4062 //double cosmax = 1.0;
4063
4064 double Nf;
4065
4066 double pLH, pRH; //Polarization factors, minus the 1/4 average
4067
4068 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4069 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4070
4071 if (f.is("LEPTON")) {
4072 Nf = 1.0;
4073 } else {
4074 Nf = 3.0;
4075 }
4076
4077 sumM2 = (pLH * MLR2eeff(f, s) + pRH * MRL2eeff(f, s)) * tovers2(cosmin, cosmax)
4078 + (pLH * MLL2eeff(f, s, tdumm) + pRH * MRR2eeff(f, s, tdumm)) * uovers2(cosmin, cosmax);
4079
4080 sigma = Nf * 0.5 * M_PI * (alphaMz())*(alphaMz()) * sumM2 / s;
4081
4082 return topb * sigma;
4083}
const double MRL2eeff(const Particle f, const double s) const
const double uovers2(const double cosmin, const double cosmax) const
const double tovers2(const double cosmin, const double cosmax) const
const double MLL2eeff(const Particle f, const double s, const double t) const
const double MRR2eeff(const Particle f, const double s, const double t) const
const double MLR2eeff(const Particle f, const double s) const

◆ eeffsigmaBottom()

virtual const double StandardModel::eeffsigmaBottom ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3221 of file StandardModel.h.

3222 {
3223 return eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 1.0);
3224 }

◆ eeffsigmaCharm()

virtual const double StandardModel::eeffsigmaCharm ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3216 of file StandardModel.h.

3217 {
3218 return eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 1.0);
3219 }

◆ eeffsigmaE()

virtual const double StandardModel::eeffsigmaE ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3176 of file StandardModel.h.

3177 {
3178 double cosmin = -0.90; // As in LEP2
3179 double cosmax = 0.90; // As in LEP2
3180
3181 return eeffsigmaEbin(pol_e, pol_p, s, cosmin, cosmax);
3182 }

◆ eeffsigmaEbin()

const double StandardModel::eeffsigmaEbin ( const double  pol_e,
const double  pol_p,
const double  s,
const double  cosmin,
const double  cosmax 
) const

Definition at line 4025 of file StandardModel/src/StandardModel.cpp.

4025 {
4026
4027 double sumM2, sigma;
4028 double topb = 0.3894e+9;
4029 double t0, t1, lambdaK;
4030
4031 double pLH, pRH; //Polarization factors, minus the 1/4 average
4032
4033 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4034 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4035
4036 // t values for cosmin and cosmax
4037 t0 = 0.5 * s * ( -1.0 + cosmin );
4038 t1 = 0.5 * s * ( -1.0 + cosmax );
4039
4040 // Kähllén function of (s,0,0)
4041 lambdaK = s*s;
4042
4043 // Sum of the integrals of the amplitudes squared x (t/s)^2, (s/t)^2, (u/s)^2
4044 sumM2 = (pLH + pRH) * ( intMLR2eeeets2(s, t0, t1) + intMLRtilde2eeeest2(s, t0, t1) ) +
4045 pLH * intMLL2eeeeus2(s, t0, t1) + pRH * intMRR2eeeeus2(s, t0, t1);
4046
4047 // Build the cross section
4048 sigma = M_PI * (alphaMz())*(alphaMz()) * sumM2 / s / sqrt(lambdaK);
4049
4050 return topb * sigma;
4051
4052}
const double intMLR2eeeets2(const double s, const double t0, const double t1) const
const double intMLRtilde2eeeest2(const double s, const double t0, const double t1) const
const double intMRR2eeeeus2(const double s, const double t0, const double t1) const
const double intMLL2eeeeus2(const double s, const double t0, const double t1) const

◆ eeffsigmaEtsub()

virtual const double StandardModel::eeffsigmaEtsub ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3186 of file StandardModel.h.

3187 {
3188 double cosmin = -0.90; // As in LEP2
3189 double cosmax = 0.90; // As in LEP2
3190
3191 return eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, cosmin, cosmax);
3192 }

◆ eeffsigmaHadron()

virtual const double StandardModel::eeffsigmaHadron ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3204 of file StandardModel.h.

3205 {
3206 return ( eeffsigma(quarks[UP], pol_e, pol_p, s, -1.0, 1.0) + eeffsigma(quarks[DOWN], pol_e, pol_p, s, -1.0, 1.0)
3207 + eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 1.0) + eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 1.0)
3208 + eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 1.0) );
3209 }

◆ eeffsigmaMu()

virtual const double StandardModel::eeffsigmaMu ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3194 of file StandardModel.h.

3195 {
3196 return eeffsigma(leptons[MU], pol_e, pol_p, s, -1.0, 1.0);
3197 }

◆ eeffsigmaStrange()

virtual const double StandardModel::eeffsigmaStrange ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3211 of file StandardModel.h.

3212 {
3213 return eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 1.0);
3214 }

◆ eeffsigmaTau()

virtual const double StandardModel::eeffsigmaTau ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3199 of file StandardModel.h.

3200 {
3201 return eeffsigma(leptons[TAU], pol_e, pol_p, s, -1.0, 1.0);
3202 }

◆ epsilon1()

const double StandardModel::epsilon1 ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_1\).

The parameters \(\varepsilon_1\) is defined as

\[ \varepsilon_1 = \Delta\rho'\,, \]

where \(\Delta\rho'=2\left(\sqrt{{\rm Re}(\rho_Z^e)}-1\right)\).

See [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(\varepsilon_{1,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1800 of file StandardModel/src/StandardModel.cpp.

1801{
1802 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1803 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1804
1805 return DeltaRhoPrime;
1806}
virtual const gslpp::complex rhoZ_f(const Particle f) const
The effective leptonic neutral-current coupling in the SM.

◆ epsilon2()

const double StandardModel::epsilon2 ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_2\).

The parameters \(\varepsilon_2\) is computed via the formula:

\[ \varepsilon_2 = c_0^2 \Delta\rho' + \frac{s_0^2}{c_0^2 - s_0^2} \Delta r_W - 2 s_0^2 \Delta\kappa'\,, \]

where \(\Delta\rho'\), \(\Delta r_W\) and \(\Delta\kappa'\) are defined as

\begin{align} \Delta\rho'=2\left(\sqrt{{\rm Re}(\rho_Z^e)}-1\right),\qquad \Delta r_W = 1 - \frac{\pi\,\alpha(M_Z^2)}{\sqrt{2}\,G_\mu M_Z^2 s_W^2 c_W^2},\qquad \Delta\kappa' = \frac{\sin^2\theta_{\mathrm{eff}}^e}{s_0^2} - 1\,, \end{align}

and \(s_0^2\) and \(c_0^2\) are given in s02() and c02(), respectively.

See [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(\varepsilon_{2,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1808 of file StandardModel/src/StandardModel.cpp.

1809{
1810 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1811 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1812 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1813 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1814 double DeltaRW = 1.0 - M_PI * alphaMz() / (sqrt(2.0) * GF * Mz * Mz * sW2() * cW2());
1815
1816 return ( c02() * DeltaRhoPrime + s02() * DeltaRW / (c02() - s02())
1817 - 2.0 * s02() * DeltaKappaPrime);
1818}
const double c02() const
The square of the cosine of the weak mixing angle defined without weak radiative corrections.
An observable class for the leptonic effective weak mixing angle at the pole. To be used for the el...
Definition: sin2thetaEff.h:29

◆ epsilon3()

const double StandardModel::epsilon3 ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_3\).

The parameters \(\varepsilon_3\) is computed via the formula:

\[ \varepsilon_3 = c_0^2\Delta\rho' + (c_0^2-s_0^2)\Delta\kappa'\,, \]

where \(\Delta\rho'\) and \(\Delta\kappa'\) are defined as

\begin{align} \Delta\rho'=2\left(\sqrt{{\rm Re}(\rho_Z^e)}-1\right),\qquad \Delta\kappa' = \frac{\sin^2\theta_{\mathrm{eff}}^e}{s_0^2} - 1\,, \end{align}

and \(s_0^2\) and \(c_0^2\) are given in s02() and c02(), respectively.

See [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(\varepsilon_{3,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1820 of file StandardModel/src/StandardModel.cpp.

1821{
1822 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1823 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1824 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1825 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1826
1827 return ( c02() * DeltaRhoPrime + (c02() - s02()) * DeltaKappaPrime);
1828}

◆ epsilonb()

const double StandardModel::epsilonb ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_b\).

The parameters \(\varepsilon_b\) is computed via the formula:

\[ \epsilon_b = \frac{ {\rm Re}\left[ \kappa_Z^e + \Delta\kappa_Z^b \right]} {{\rm Re}(\kappa_Z^b)} - 1\,, \]

where \(\Delta\kappa_Z^b\), representing flavour non-universal vertex corrections to the \(Zb\bar{b}\) vertex, is neglected when the model flag WithoutNonUniversalVC of StandardModel is set to true.

See [Altarelli:1990zd], [Altarelli:1991fk] and [Altarelli:1993sz] for the \(\varepsilon\) parameterization and [Ciuchini:2013pca] for the flavour non-universal vertex corrections.

Returns
\(\varepsilon_{b,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1830 of file StandardModel/src/StandardModel.cpp.

1831{
1832 /* epsilon_b from g_A^b
1833 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1834 //double rhoZe = rhoZ_l_SM(StandardModel::ELECTRON).real();
1835 //double rhoZb = rhoZ_q_SM(QCD::BOTTOM).real();
1836 //double DeltaRhoPrime = 2.0*( sqrt(rhoZe) - 1.0 );
1837 //double eps1 = DeltaRhoPrime;
1838 //return ( - 1.0 + sqrt(rhoZb)/(1.0 + eps1/2.0) );
1839
1840 /* epsilon_b from Re(g_V^b/g_A^b), i.e. Re(kappaZ_b)
1841 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1842 gslpp::complex kappaZe = kappaZ_f(leptons[ELECTRON]);
1843 gslpp::complex kappaZb = kappaZ_f(quarks[BOTTOM]);
1845 return ( kappaZe.real() / kappaZb.real() - 1.0);
1846 else
1847 return ( (kappaZe.real() + deltaKappaZ_f(quarks[BOTTOM]).real())
1848 / kappaZb.real() - 1.0);
1849
1850 /* epsilon_b from Gamma_b via Eqs.(11), (12) and (16) of IJMP A7,
1851 * 1031 (1998) by Altarelli et al.
1852 * Note: mb has to be mb=4.7, since Eq.(16) were derived with this value.
1853 */
1854 //double als_Mz = Als(myCache->Mz(), FULLNNLO);
1855 //double delta_als = (als_Mz - 0.119)/M_PI;
1856 //double delta_alpha = (alphaMz() - 1.0/128.90)/myCache->ale();
1857 //double Gamma_b_Born = 0.3798*( 1.0 + delta_als - 0.42*delta_alpha);
1858 //double a = als_Mz/M_PI;
1859 //double RQCD = 1.0 + 1.2*a - 1.1*a*a - 13.0*a*a*a;
1860 //double mb = Mrun(myCache->Mz(), quarks[QCD::BOTTOM].getMass(), FULLNNLO);// This is wrong!
1861 //double mb = 4.7;
1862 //std::cout << "mb = " << mb << std::endl;
1863 //double beta = sqrt(1.0 - 4.0*mb*mb/myCache->Mz()/myCache->Mz());
1864 //double Nc = 3.0;
1865 //double factor = myCache->GF()*myCache->Mz()*myCache->Mz()*myCache->Mz()/6.0/M_PI/sqrt(2.0);
1866 //double Gamma_b = factor*beta*((3.0 - beta*beta)/2.0*gVq_SM(QCD::BOTTOM).abs2()
1867 // + beta*beta*gAq_SM(QCD::BOTTOM).abs2())
1868 // *Nc*RQCD*(1.0 + alphaMz()/12.0/M_PI);
1869 //return ( (Gamma_b/Gamma_b_Born - 1.0 - 1.42*epsilon1_SM()
1870 // + 0.54*epsilon3_SM() )/2.29 );
1871}
const bool IsFlagWithoutNonUniversalVC() const
A method to retrieve the model flag WithoutNonUniversalVC.
virtual const gslpp::complex deltaKappaZ_f(const Particle f) const
Flavour non-universal vertex corrections to , denoted by .

◆ f_triangle()

gslpp::complex StandardModel::f_triangle ( const double  tau) const

Loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings.

Parameters
[in]

_form#4737, with \(M\) the mass of the particle in the loop.

Returns
\(f(\tau)\)

Definition at line 3262 of file StandardModel/src/StandardModel.cpp.

3262 {
3263 gslpp::complex tmp;
3264 if (tau >= 1.0) {
3265 tmp = asin(1.0 / sqrt(tau));
3266 return (tmp * tmp);
3267 } else {
3268 tmp = log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i();
3269 return (-0.25 * tmp * tmp);
3270 }
3271}

◆ g_triangle()

gslpp::complex StandardModel::g_triangle ( const double  tau) const

Loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4737, with \(M\) the mass of the particle in the loop.

Returns
\(g(\tau)\)

Definition at line 3273 of file StandardModel/src/StandardModel.cpp.

3273 {
3274 gslpp::complex tmp;
3275 if (tau >= 1.0) {
3276 tmp = sqrt(tau - 1.0) * asin(1.0 / sqrt(tau));
3277 return tmp;
3278 } else {
3279 tmp = sqrt(1.0 - tau) * (log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i());
3280 return 0.5 * tmp;
3281 }
3282}

◆ gA_f()

const gslpp::complex StandardModel::gA_f ( const Particle  f) const
virtual

The effective leptonic neutral-current axial-vector coupling \(g_A^l\) in the SM.

\[ g_A^l = \sqrt{\rho_Z^l}\, I_3^l\,. \]

Parameters
[in]fa lepton or quark
Returns
\(g_{A,\,\mathrm{SM}}^l\)

Reimplemented in NPbase, and NPEpsilons.

Definition at line 1589 of file StandardModel/src/StandardModel.cpp.

1590{
1591 return ( sqrt(rhoZ_f(f)) * f.getIsospin());
1592}
double getIsospin() const
A get method to access the particle isospin.
Definition: Particle.h:115

◆ Gamma_had()

const double StandardModel::Gamma_had ( ) const
virtual

The hadronic decay width of the \(Z\) boson, \(\Gamma_{h}\).

The hadronic width is given by the sum,

\[ \Gamma_h = \Gamma_u + \Gamma_d + \Gamma_c + \Gamma_s + \Gamma_b\,. \]

Furthermore, the singlet vector corrections are added, following the prescription in [Bardin:1997xq] :

\[ \Gamma_h = \sum_q \Gamma_q + 4N_c\Gamma_0 R_V^h\,. \]

Returns
\(\Gamma_{h}\) in GeV

Reimplemented in NPbase.

Definition at line 1417 of file StandardModel/src/StandardModel.cpp.

1418{
1419 double Gamma_had_tmp = 0.0;
1420
1422
1423 /* SM contribution with the approximate formula */
1424 return myApproximateFormulae->X_full("Gamma_had");
1425
1426 } else {
1427
1428 Gamma_had_tmp = GammaZ(quarks[UP]) + GammaZ(quarks[DOWN]) + GammaZ(quarks[CHARM])
1430
1431 /* Singlet vector contribution (not included in the approximate formula) */
1432 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1433 Gamma_had_tmp += 4.0 * 3.0 * G0 * RVh();
1434
1435 return Gamma_had_tmp;
1436 }
1437}
double X_full(const std::string observable) const
, , , , , , , , , , , or .
virtual const double GammaZ(const Particle f) const
The partial decay width, .
const bool IsFlagNoApproximateGammaZ() const
A method to retrieve the model flag NoApproximateGammaZ.
double RVh() const
The singlet vector corrections to the hadronic -boson width, denoted as .

◆ Gamma_inv()

const double StandardModel::Gamma_inv ( ) const
virtual

The invisible partial decay width of the \(Z\) boson, \(\Gamma_{\mathrm{inv}}\).

\[ \Gamma_{\mathrm{inv}} = 3\,\Gamma_\nu\,, \]

where \(\Gamma_{\nu}\) is the partial width for \(Z\to\nu\bar{\nu}\).

Returns
\(\Gamma_{\mathrm{inv}}\) in GeV

Definition at line 1411 of file StandardModel/src/StandardModel.cpp.

1412{
1415}

◆ Gamma_muon()

const double StandardModel::Gamma_muon ( ) const
virtual

The computation of the muon decay.

Follows the formulae of PDG

Returns
\(\Gamma_\mu \)

Definition at line 3094 of file StandardModel/src/StandardModel.cpp.

3095{
3096 double Gamma;
3097 double me, mmu, x, Fx, H1x, H2x, H3x, zeta3;
3098 double alpha, rEW;
3099 double pi2;
3100
3101 me = leptons[ELECTRON].getMass();
3102 mmu = leptons[MU].getMass();
3103 pi2 = M_PI*M_PI;
3104
3105 x = me*me/mmu/mmu;
3106 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3107
3108 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3109
3110 zeta3 = 1.2020569031595942;
3111
3112 H2x= 156815./5184. - 518. * pi2/81. - 895. *zeta3/36. + 67.*pi2*pi2/720. + 53. *pi2*log(2.)/6. - 0.042 - (5./4.) * pi2*sqrt(x);
3113
3114 H3x = -15.3;
3115
3116 // alpha(m_mu)
3117 alpha = 1./ale - log(x)/3./M_PI; // + 1./6./M_PI;
3118 alpha = 1./alpha;
3119
3120 // Rad. corrections
3121 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3122
3123 // Gamma: PDG formula
3124 Gamma = GF*GF*pow(mmu,5)*Fx*rEW/192./pow(M_PI,3);
3125
3126 return Gamma;
3127}
double zeta3
computed with the GSL.
Definition: QCD.h:1033

◆ Gamma_tau_l_nunu()

const double StandardModel::Gamma_tau_l_nunu ( const Particle  l) const
virtual

The computation of the leptonic tau decays.

Follows the formulae of PDG for muon, adapted to tau leptons

Returns
\(\Gamma(\tau \to l \nu \nu ) \)

Definition at line 3134 of file StandardModel/src/StandardModel.cpp.

3135{
3136 double Gamma;
3137 double ml, mtau, x, Fx, H1x, H2x, H3x, zeta3;
3138 double alpha, rEW;
3139 double pi2;
3140
3141 ml = l.getMass();
3142 mtau = leptons[TAU].getMass();
3143 pi2 = M_PI*M_PI;
3144
3145 x = ml*ml/mtau/mtau;
3146 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3147
3148 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3149
3150 zeta3 = 1.2020569031595942;
3151
3152 H2x= 156815./5184. - 518. * pi2/81. - 895. *zeta3/36. + 67.*pi2*pi2/720. + 53. *pi2*log(2.)/6. - 0.042 - (5./4.) * pi2*sqrt(x);
3153
3154 H3x = -15.3;
3155
3156 // alpha(m_tau)
3157 alpha = 1./133.29; // Improve
3158
3159 // Rad. corrections
3160 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3161
3162 // Gamma: PDG formula
3163 Gamma = GF*GF*pow(mtau,5)*Fx*rEW/192./pow(M_PI,3);
3164
3165 return Gamma;
3166}

◆ Gamma_Z()

const double StandardModel::Gamma_Z ( ) const
virtual

The total decay width of the \(Z\) boson, \(\Gamma_Z\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(\Gamma_Z\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, the total decay width is calculated with

\[ \Gamma_Z = \Gamma_{e} + \Gamma_{\mu} + \Gamma_{\tau} + \Gamma_{\mathrm{inv}} + \Gamma_h\,. \]

Returns
\(\Gamma_Z\) in GeV

Reimplemented in NPbase, NPEpsilons, NPSMEFTd6General, and NPZbbbar.

Definition at line 1439 of file StandardModel/src/StandardModel.cpp.

1440{
1442
1443 /* SM contribution with the approximate formula */
1444 return myApproximateFormulae->X_full("GammaZ");
1445
1446 } else {
1448 + Gamma_inv() + Gamma_had());
1449 }
1450}
virtual const double Gamma_inv() const
The invisible partial decay width of the boson, .
virtual const double Gamma_had() const
The hadronic decay width of the boson, .

◆ GammaHtobb()

const double StandardModel::GammaHtobb ( ) const
virtual

The \(\Gamma(H\to b \bar{b})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to b \bar{b})\)

Definition at line 3610 of file StandardModel/src/StandardModel.cpp.

3611{
3612 double mf0=quarks[BOTTOM].getMass(), mf;
3613 double beta;
3614 double Nc=3.0;
3615 double gamma;
3616 double asMH,DeltaQCD,Deltamt,NF;
3617
3618 // alfa_s(MH)
3619 asMH = Als(mHl, FULLNLO);
3620
3621 mf = Mrun(mHl, mf0, mf0, BOTTOM, FULLNLO);
3622
3623 beta=1.0-4.0*mf*mf/mHl/mHl;
3624
3625 NF=5;
3626
3627 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3628
3629 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3630
3631 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3632
3633 return gamma;
3634}
const double Mrun(const double mu, const double m, const quark q, const orders order=FULLNNLO) const
Computes a running quark mass from .
Definition: QCD.cpp:1353

◆ GammaHtocc()

const double StandardModel::GammaHtocc ( ) const
virtual

The \(\Gamma(H\to c \bar{c})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to c \bar{c})\)

Definition at line 3558 of file StandardModel/src/StandardModel.cpp.

3559{
3560 double mf0=quarks[CHARM].getMass(), mf;
3561 double beta;
3562 double Nc=3.0;
3563 double gamma;
3564 double asMH,DeltaQCD,Deltamt,NF;
3565
3566 // alfa_s(MH)
3567 asMH = Als(mHl, FULLNLO);
3568
3569 mf = Mrun(mHl, mf0, mf0, CHARM, FULLNLO);
3570
3571 beta=1.0-4.0*mf*mf/mHl/mHl;
3572
3573 NF=5;
3574
3575 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3576
3577 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3578
3579 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3580
3581 return gamma;
3582}

◆ GammaHtogaga()

const double StandardModel::GammaHtogaga ( ) const
virtual

The \(\Gamma(H\to \gamma \gamma)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to \gamma \gamma)\)

Definition at line 3491 of file StandardModel/src/StandardModel.cpp.

3492{
3493 double gamma;
3494
3495 double m_t = mtpole;
3496 double m_b = quarks[BOTTOM].getMass();
3497 double m_c = quarks[CHARM].getMass();
3498 double m_s = quarks[STRANGE].getMass();
3499 double m_tau = leptons[TAU].getMass();
3500 double m_mu = leptons[MU].getMass();
3501
3502 double M_w_2 = pow(Mw(),2.0);
3503
3504 double Qt = quarks[TOP].getCharge();
3505 double Qb = quarks[BOTTOM].getCharge();
3506 double Qc = quarks[CHARM].getCharge();
3507 double Qs = quarks[STRANGE].getCharge();
3508 double Qtau = leptons[TAU].getCharge();
3509 double Qmu = leptons[MU].getCharge();
3510
3511 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3512 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3513 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3514 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3515 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3516 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3517 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3518
3519 gslpp::complex MSM;
3520
3521 MSM = ale * (3.0 * Qt * Qt * AH_f(tau_t) +
3522 3.0 * Qb * Qb * AH_f(tau_b) +
3523 3.0 * Qc * Qc * AH_f(tau_c) +
3524 3.0 * Qs * Qs * AH_f(tau_s) +
3525 Qtau * Qtau * AH_f(tau_tau) +
3526 Qmu * Qmu * AH_f(tau_mu) +
3527 AH_W(tau_W));
3528
3529 gamma = (4.0*GF/sqrt(2)) * (MSM.abs2()) * pow(mHl,3.0)/512.0/pow(M_PI,3);
3530
3531 return gamma;
3532}
gslpp::complex AH_f(const double tau) const
Fermionic loop function entering in the calculation of the effective and couplings.
gslpp::complex AH_W(const double tau) const
W loop function entering in the calculation of the effective coupling.

◆ GammaHtogg()

const double StandardModel::GammaHtogg ( ) const
virtual

The \(\Gamma(H\to gg)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to gg)\)

Definition at line 3368 of file StandardModel/src/StandardModel.cpp.

3369{
3370 double gamma;
3371 double tau_t = 4.0 * pow(quarks[TOP].getMass(),2)/mHl/mHl;
3372 double tau_b = 4.0 * pow(quarks[BOTTOM].getMass(),2)/mHl/mHl;
3373 double tau_c = 4.0 * pow(quarks[CHARM].getMass(),2)/mHl/mHl;
3374 double tau_s = 4.0 * pow(quarks[STRANGE].getMass(),2)/mHl/mHl;
3375 double asMH,LH,Lt,nl,h0,h1,h2, h3,G0;
3376
3377 // alfa_s(MH)
3378 asMH = Als(mHl, FULLNLO);
3379
3380 // NLO corrections ( See https://arxiv.org/pdf/0708.0916 and its REf. [25])
3381 // I only keep up to h3 in expr. (4), and use pole mass in tau factors for the moment
3382 nl = 5;
3383 LH = 0.; // log(mu^2/MH^2) evaluated at mu=MH
3384 Lt = 2.0*log(mHl/(quarks[TOP].getMass()));
3385
3386 h0 = (95./4.) + (11./2.)*LH + nl*(-7./6. - LH/3.);
3387 h1 = 5803./540. + 77.*LH/30. -14.*Lt/15. + nl * (-29./60. - 7. * LH / 45.);
3388 h2 = 1029839./189000. + 16973.*LH/12600. - 1543.*Lt/1575. + nl * ( - 89533./378000 - 1543.*LH/18900. );
3389 h3 = 9075763./2976750. + 1243*LH/1575. - 452.*Lt/575. + nl * ( - 3763./28350. -226. * LH / 4725. );
3390 G0 = GF * pow(mHl,3.0)/(36.*M_PI*sqrt(2.));
3391
3392 gamma = asMH*asMH * (4.0 * GF /sqrt(2.0)) * (mHl*mHl*mHl /64.0/pow(M_PI,3.0)) *
3393 ( AH_f(tau_t) + AH_f(tau_b) + AH_f(tau_c) + AH_f(tau_s) ).abs2()/4.0;
3394
3395 gamma = gamma + G0 * (asMH/M_PI) * (asMH/M_PI) * (asMH/M_PI) * (h0 + h1/tau_t + h2/tau_t/tau_t + h3/tau_t/tau_t/tau_t );
3396
3397 return gamma;
3398}

◆ GammaHtomumu()

const double StandardModel::GammaHtomumu ( ) const
virtual

The \(\Gamma(H\to \mu^+ \mu^-)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to \mu^+ \mu^-)\)

Definition at line 3534 of file StandardModel/src/StandardModel.cpp.

3535{
3536 double mf=leptons[MU].getMass();
3537 double beta=1.0-4.0*mf*mf/mHl/mHl;
3538 double Nc=1.0;
3539 double gamma;
3540
3541 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3542
3543 return gamma;
3544}

◆ GammaHtoss()

const double StandardModel::GammaHtoss ( ) const
virtual

The \(\Gamma(H\to s \bar{s})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to s \bar{s})\)

Definition at line 3584 of file StandardModel/src/StandardModel.cpp.

3585{
3586 double mf0=quarks[STRANGE].getMass(), mf;
3587 double beta;
3588 double Nc=3.0;
3589 double gamma;
3590 double asMH,DeltaQCD,Deltamt,NF;
3591
3592 // alfa_s(MH)
3593 asMH = Als(mHl, FULLNLO);
3594
3595 mf = Mrun(mHl, 2.0, mf0, STRANGE, FULLNLO);
3596
3597 beta=1.0-4.0*mf*mf/mHl/mHl;
3598
3599 NF=5;
3600
3601 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3602
3603 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3604
3605 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3606
3607 return gamma;
3608}

◆ GammaHTot()

const double StandardModel::GammaHTot ( ) const
virtual

The total Higgs width \(\Gamma(H)\) in the Standard Model.

At the same level of the individual contributions

Returns
\(\Gamma(H)\)

Definition at line 3636 of file StandardModel/src/StandardModel.cpp.

3637{
3638 double gamma;
3639
3640 gamma = GammaHtobb() + GammaHtocc() + GammaHtoss() +
3644
3645 return gamma;
3646}

◆ GammaHtotautau()

const double StandardModel::GammaHtotautau ( ) const
virtual

The \(\Gamma(H\to \tau^+ \tau^-)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to \tau^+ \tau^-)\)

Definition at line 3546 of file StandardModel/src/StandardModel.cpp.

3547{
3548 double mf=leptons[TAU].getMass();
3549 double beta=1.0-4.0*mf*mf/mHl/mHl;
3550 double Nc=1.0;
3551 double gamma;
3552
3553 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3554
3555 return gamma;
3556}

◆ GammaHtoWWstar()

const double StandardModel::GammaHtoWWstar ( ) const
virtual

The \(\Gamma(H\to W W^*)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to W W^*)\)

Definition at line 3416 of file StandardModel/src/StandardModel.cpp.

3417{
3418 double x=Mw()/mHl;
3419 double fx;
3420 double g2 = 4.0 * sqrt(2.0) * GF * pow(Mw(),2);
3421 double gamma;
3422
3423 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3424 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3425 3.0*( 1.0 - 8.0*x*x + 20.0*x*x*x*x )*acos(( 3.0*x*x - 1.0 )/2.0/x/x/x)/sqrt( 4.0*x*x- 1.0);
3426
3427 gamma = 3.0 * g2*g2 * mHl * fx / 512.0 / pow(M_PI,3.0);
3428
3429 return gamma;
3430}

◆ GammaHtoZga()

const double StandardModel::GammaHtoZga ( ) const
virtual

The \(\Gamma(H\to Z \gamma)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to Z \gamma)\)

Definition at line 3432 of file StandardModel/src/StandardModel.cpp.

3433{
3434 double gamma;
3435
3436 double m_t = mtpole;
3437 double m_b = quarks[BOTTOM].getMass();
3438 double m_c = quarks[CHARM].getMass();
3439 double m_s = quarks[STRANGE].getMass();
3440 double m_tau = leptons[TAU].getMass();
3441 double m_mu = leptons[MU].getMass();
3442
3443 double M_w_2 = pow(Mw(),2.0);
3444
3445 double Qt = quarks[TOP].getCharge();
3446 double Qb = quarks[BOTTOM].getCharge();
3447 double Qc = quarks[CHARM].getCharge();
3448 double Qs = quarks[STRANGE].getCharge();
3449 double Qtau = leptons[TAU].getCharge();
3450 double Qmu = leptons[MU].getCharge();
3451
3452 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3453 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3454 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3455 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3456 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3457 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3458 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3459
3460 double lambda_t = 4.0 * m_t * m_t / Mz / Mz;
3461 double lambda_b = 4.0 * m_b * m_b / Mz / Mz;
3462 double lambda_c = 4.0 * m_c * m_c / Mz / Mz;
3463 double lambda_s = 4.0 * m_s * m_s / Mz / Mz;
3464 double lambda_tau = 4.0 * m_tau * m_tau / Mz / Mz;
3465 double lambda_mu = 4.0 * m_mu * m_mu / Mz / Mz;
3466 double lambda_W = 4.0 * M_w_2 / Mz / Mz;
3467
3468 double sc = sqrt(sW2()*cW2());
3469 double vSMt = (2.0 * (quarks[TOP].getIsospin()) - 4.0 * Qt * sW2())/sc;
3470 double vSMb = (2.0 * (quarks[BOTTOM].getIsospin()) - 4.0 * Qb * sW2())/sc;
3471 double vSMc = (2.0 * (quarks[CHARM].getIsospin()) - 4.0 * Qc * sW2())/sc;
3472 double vSMs = (2.0 * (quarks[STRANGE].getIsospin()) - 4.0 * Qs * sW2())/sc;
3473 double vSMtau = (2.0 * (leptons[TAU].getIsospin()) - 4.0 * Qtau * sW2())/sc;
3474 double vSMmu = (2.0 * (leptons[MU].getIsospin()) - 4.0 * Qmu * sW2())/sc;
3475
3476 gslpp::complex MSM;
3477
3478 MSM = (ale/4.0/M_PI) * ((3.0 * vSMt * Qt * AHZga_f(tau_t, lambda_t) +
3479 3.0 * vSMb * Qb * AHZga_f(tau_b, lambda_b) +
3480 3.0 * vSMc * Qc * AHZga_f(tau_c, lambda_c) +
3481 3.0 * vSMs * Qs * AHZga_f(tau_s, lambda_s) +
3482 vSMtau * Qtau * AHZga_f(tau_tau, lambda_tau) +
3483 vSMmu * Qmu * AHZga_f(tau_mu, lambda_mu)) +
3484 AHZga_W(tau_W, lambda_W)/sqrt(sW2()));
3485
3486 gamma = (4.0*sqrt(2)*GF) * (MSM.abs2()) * pow(mHl*(1.0-Mz*Mz/mHl/mHl),3.0)/32.0/M_PI;
3487
3488 return gamma;
3489}
gslpp::complex AHZga_W(const double tau, const double lambda) const
W loop function entering in the calculation of the effective coupling.
gslpp::complex AHZga_f(const double tau, const double lambda) const
Fermionic loop function entering in the calculation of the effective coupling.

◆ GammaHtoZZstar()

const double StandardModel::GammaHtoZZstar ( ) const
virtual

The \(\Gamma(H\to Z Z^*)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to Z Z^*)\)

Definition at line 3400 of file StandardModel/src/StandardModel.cpp.

3401{
3402 double x=Mz/mHl;
3403 double fx;
3404 double g2 = 4.0 * sqrt(2.0) * GF * Mz * Mz;
3405 double gamma;
3406
3407 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3408 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3409 3.0*( 1.0 - 8.0*x*x + 20.0*x*x*x*x )*acos(( 3.0*x*x - 1.0 )/2.0/x/x/x)/sqrt( 4.0*x*x- 1.0);
3410
3411 gamma = g2*g2 * mHl * fx * ( 7.0 - 40.0*sW2()/3.0 + 160.0 *sW2()*sW2()/9.0 ) / 2048.0 / pow(M_PI,3.0);
3412
3413 return gamma;
3414}

◆ GammaW() [1/2]

const double StandardModel::GammaW ( ) const
virtual

The total width of the \(W\) boson, \(\Gamma_W\).

Returns
\(\Gamma_W\) in GeV

Reimplemented in NPbase, NPEpsilons, NPEpsilons_pureNP, NPSMEFTd6, NPSMEFTd6General, NPSTUVWXY, and NPZbbbar.

Definition at line 1272 of file StandardModel/src/StandardModel.cpp.

1273{
1275 if (useGammaW_cache)
1276 return GammaW_cache;
1277
1278 double GammaWtmp = 0.;
1279
1280 for (int i = 0; i < 6; i += 2)
1281 GammaWtmp += GammaW(leptons[i], leptons[i + 1]) + GammaW(quarks[i], quarks[i + 1]);
1282
1283 GammaW_cache = GammaWtmp;
1284 useGammaW_cache = true;
1285 return GammaWtmp;
1286}

◆ GammaW() [2/2]

const double StandardModel::GammaW ( const Particle  fi,
const Particle  fj 
) const
virtual

A partial decay width of the \(W\) boson decay into a SM fermion pair.

\[ \Gamma^W_{ij} = |U_{ij}|^2\,\frac{G_\mu M_W^3}{6\sqrt{2}\,\pi}\,\rho^W_{ij} \]

where \(U\) denotes the MNS matrix, and \(\rho^W_{ij}\) represents EW radiative corrections.

\[ \Gamma^W_{ij} = 3 |V_{ij}|^2\,\frac{G_\mu M_W^3}{6\sqrt{2}\,\pi}\,\rho^W_{ij} \left( 1 + \frac{\alpha_s(M_W^2)}{\pi} \right). \]

where \(V\) denotes the CKM matrix, and \(\rho^W_{ij}\) represents EW radiative corrections.

Parameters
[in]fia lepton or quark
[in]fja lepton or quark
Returns
\(\Gamma^W_{ij}\)
See also
rho_GammaW_l_SM()
Attention
Fermion masses are neglected.

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1248 of file StandardModel/src/StandardModel.cpp.

1249{
1250 if ((fi.getIndex()) % 2 || (fj.getIndex() + 1) % 2)
1251 throw std::runtime_error("Error in StandardModel::GammaW()");
1252
1253 double G0 = GF * pow(Mw(), 3.0) / 6.0 / sqrt(2.0) / M_PI;
1254 gslpp::complex V(0.0, 0.0, false);
1255
1256 if (fi.is("TOP"))
1257 return (0.0);
1258
1259 if (fj.getIndex() - fi.getIndex() == 1)
1260 V = gslpp::complex(1.0, 0.0, false);
1261 else
1262 V = gslpp::complex(0.0, 0.0, false);
1263
1264 if (fi.is("LEPTON"))
1265 return ( V.abs2() * G0 * rho_GammaW(fi, fj) * ( 1.0 + delGammaWlv ) );
1266 else {
1267 double AlsMw = AlsWithInit(Mw(), AlsMz, Mz, 5, FULLNLO);
1268 return ( 3.0 * V.abs2() * G0 * rho_GammaW(fi, fj) * (1.0 + AlsMw / M_PI) * ( 1.0 + delGammaWqq ) );
1269 }
1270}
int getIndex() const
Definition: Particle.h:160
virtual const double rho_GammaW(const Particle fi, const Particle fj) const
EW radiative corrections to the width of , denoted as .

◆ GammaZ()

const double StandardModel::GammaZ ( const Particle  f) const
virtual

The \(Z\to \ell\bar{\ell}\) partial decay width, \(\Gamma_\ell\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(\Gamma_\ell\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, the partial width is calculated with \(\rho_Z^\ell\) and \(g_{V}^\ell/g_{A}^\ell\) [Bardin:1999ak] :

\[ \Gamma_\ell = \Gamma_0 \big|\rho_Z^f\big| \sqrt{1-\frac{4m_\ell^2}{M_Z^2}} \left[ \left(1+\frac{2m_\ell^2}{M_Z^2}\right) \left(\left|\frac{g_{V}^\ell}{g_{A}^\ell}\right|^2 + 1 \right) - \frac{6m_\ell^2}{M_Z^2} \right] \left( 1 + \frac{3}{4}\frac{\alpha(M_Z^2)}{\pi}\, Q_\ell^2 \right) \]

with \(\Gamma_0=G_\mu M_Z^3/(24\sqrt{2}\pi)\).

Parameters
[in]fa lepton or quark
Returns
\(\Gamma_\ell\) in GeV
Attention
\(\ell\) stands for both a neutrino and a charged lepton.

Definition at line 1363 of file StandardModel/src/StandardModel.cpp.

1364{
1365 if (f.is("TOP"))
1366 return 0.0;
1367 double Gamma;
1369
1370 /* SM contribution with the approximate formula */
1371 if (f.is("NEUTRINO_1") || f.is("NEUTRINO_2") || f.is("NEUTRINO_3"))
1372 Gamma = myApproximateFormulae->X_full("Gamma_nu");
1373 else if (f.is("ELECTRON") || f.is("MU"))
1374 Gamma = myApproximateFormulae->X_full("Gamma_e_mu");
1375 else if (f.is("TAU"))
1376 Gamma = myApproximateFormulae->X_full("Gamma_tau");
1377 else if (f.is("UP"))
1378 Gamma = myApproximateFormulae->X_full("Gamma_u");
1379 else if (f.is("CHARM"))
1380 Gamma = myApproximateFormulae->X_full("Gamma_c");
1381 else if (f.is("DOWN") || f.is("STRANGE"))
1382 Gamma = myApproximateFormulae->X_full("Gamma_d_s");
1383 else if (f.is("BOTTOM"))
1384 Gamma = myApproximateFormulae->X_full("Gamma_b");
1385 else
1386 throw std::runtime_error("Error in StandardModel::GammaZ()");
1387
1388 } else {
1389 gslpp::complex myrhoZ_f = rhoZ_f(f);
1390 gslpp::complex gV_over_gA = gV_f(f) / gA_f(f);
1391 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1392 if (f.is("LEPTON")) {
1393 double myalphaMz = alphaMz();
1394 double Q = f.getCharge();
1395 double xl = pow(f.getMass() / Mz, 2.0);
1396 Gamma = G0 * myrhoZ_f.abs() * sqrt(1.0 - 4.0 * xl)
1397 * ((1.0 + 2.0 * xl)*(gV_over_gA.abs2() + 1.0) - 6.0 * xl)
1398 * (1.0 + 3.0 / 4.0 * myalphaMz / M_PI * pow(Q, 2.0));
1399 } else if (f.is("QUARK")) {
1400 Gamma = 3.0 * G0 * myrhoZ_f.abs()*(gV_over_gA.abs2() * RVq((QCD::quark) (f.getIndex() - 6)) + RAq((QCD::quark) (f.getIndex() - 6)));
1401
1402 /* Nonfactorizable EW-QCD corrections */
1403 Gamma += Delta_EWQCD((QCD::quark) (f.getIndex() - 6));
1404 } else
1405 throw std::runtime_error("Error in StandardModel::GammaZ()");
1406 }
1407
1408 return Gamma;
1409}
double Delta_EWQCD(const QCD::quark q) const
The non-factorizable EW-QCD corrections to the partial widths for , denoted as .
double RAq(const QCD::quark q) const
The radiator factor associated with the final-state QED and QCD corrections to the the axial-vector-c...
double RVq(const QCD::quark q) const
The radiator factor associated with the final-state QED and QCD corrections to the the vector-current...
virtual const gslpp::complex gA_f(const Particle f) const
The effective leptonic neutral-current axial-vector coupling in the SM.
virtual const gslpp::complex gV_f(const Particle f) const
The effective leptonic neutral-current vector coupling in the SM.

◆ gAnue()

const double StandardModel::gAnue ( ) const
virtual

The effective (muon) neutrino-electron axial-vector coupling: gAnue.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_A^{\nu_\mu e}\)

Reimplemented in NPbase.

Definition at line 3074 of file StandardModel/src/StandardModel.cpp.

3075{
3076 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3078
3079 /* SM contribution with the approximate formula */
3081
3082 } else {
3083 throw std::runtime_error("ERROR: StandardModel::gAnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3084 }
3085}
double LEgAnueApprox() const
The effective (muon) neutrino-electron axial-vector coupling: gAnue.

◆ getAle()

const double StandardModel::getAle ( ) const
inline

A get method to retrieve the fine-structure constant \(\alpha\).

Returns
\(\alpha\)

Definition at line 801 of file StandardModel.h.

802 {
803 return ale;
804 }

◆ getAlsMz()

const double StandardModel::getAlsMz ( ) const
inline

A get method to access the value of \(\alpha_s(M_Z)\).

Returns
the strong coupling constant at \(M_Z\), \(\alpha_s(M_Z)\)

Definition at line 783 of file StandardModel.h.

784 {
785 return AlsMz;
786 }

◆ getCBd()

virtual const double StandardModel::getCBd ( ) const
inlinevirtual

The ratio of the absolute value of the $B_d$ mixing amplitude over the Standard Model value.

Returns
\(\vert (M_{12}^{bd})_\mathrm{full}/(M_{12}^{bd})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 3098 of file StandardModel.h.

3099 {
3100 return 1.;
3101 }

◆ getCBs()

virtual const double StandardModel::getCBs ( ) const
inlinevirtual

The ratio of the absolute value of the $B_s$ mixing amplitude over the Standard Model value.

Returns
\(\vert (M_{12}^{bs})_\mathrm{full}/(M_{12}^{bs})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 3107 of file StandardModel.h.

3108 {
3109 return 1.;
3110 }

◆ getCCC1()

virtual const double StandardModel::getCCC1 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1205 of file StandardModel.h.

1205{ return 0.; };

◆ getCCC2()

virtual const double StandardModel::getCCC2 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1210 of file StandardModel.h.

1210{ return 0.; };

◆ getCCC3()

virtual const double StandardModel::getCCC3 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1215 of file StandardModel.h.

1215{ return 0.; };

◆ getCCC4()

virtual const double StandardModel::getCCC4 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Definition at line 1220 of file StandardModel.h.

1220{ return 0.; };

◆ getCCC5()

virtual const double StandardModel::getCCC5 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Definition at line 1225 of file StandardModel.h.

1225{ return 0.; };

◆ getCDMK()

virtual const double StandardModel::getCDMK ( ) const
inlinevirtual

The ratio of the real part of the $K$ mixing amplitude over the Standard Model value.

Returns
\((\mathrm{Re} M_{12}^{sd})_\mathrm{full}/(\mathrm{Re} M_{12}^{sd})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 3116 of file StandardModel.h.

3117 {
3118 return 1.;
3119 }

◆ getCepsK()

virtual const double StandardModel::getCepsK ( ) const
inlinevirtual

The ratio of the imaginary part of the $K$ mixing amplitude over the Standard Model value.

Returns
\((\mathrm{Im} M_{12}^{sd})_\mathrm{full}/(\mathrm{Im} M_{12}^{sd})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 3125 of file StandardModel.h.

3126 {
3127 return 1.;
3128 }

◆ getCKM()

const CKM & StandardModel::getCKM ( ) const
inline

A get method to retrieve the member object of type CKM.

Returns
a reference to the object of type CKM

Definition at line 952 of file StandardModel.h.

953 {
954 return myCKM;
955 }

◆ getDAle5Mz()

const double StandardModel::getDAle5Mz ( ) const
inline

A get method to retrieve the five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\).

Returns
\(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\)

Definition at line 812 of file StandardModel.h.

813 {
814 return dAle5Mz;
815 }

◆ getDelGammaWlv()

const double StandardModel::getDelGammaWlv ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\Gamma_W_{l\nu}\), denoted as \(\delta\,\Gamma_W_{l\nu}\).

Returns
\(\delta\,\Gamma_W_{l\nu}\) in GeV

Definition at line 924 of file StandardModel.h.

925 {
926 return delGammaWlv;
927 }

◆ getDelGammaWqq()

const double StandardModel::getDelGammaWqq ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\Gamma_W_{qq}\), denoted as \(\delta\,\Gamma_W_{qq}\).

Returns
\(\delta\,\Gamma_W_{qq}\) in GeV

Definition at line 934 of file StandardModel.h.

935 {
936 return delGammaWqq;
937 }

◆ getDelGammaZ()

const double StandardModel::getDelGammaZ ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\).

Returns
\(\delta\,\Gamma_Z\) in GeV

Definition at line 874 of file StandardModel.h.

875 {
876 return delGammaZ;
877 }

◆ getDelMw()

const double StandardModel::getDelMw ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\).

Returns
\(\delta\,M_W\) in GeV

Definition at line 831 of file StandardModel.h.

832 {
833 return delMw;
834 }

◆ getDelR0b()

const double StandardModel::getDelR0b ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\).

Returns
\(\delta\,R_b^0\)

Definition at line 914 of file StandardModel.h.

915 {
916 return delR0b;
917 }

◆ getDelR0c()

const double StandardModel::getDelR0c ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\).

Returns
\(\delta\,R_c^0\)

Definition at line 904 of file StandardModel.h.

905 {
906 return delR0c;
907 }

◆ getDelR0l()

const double StandardModel::getDelR0l ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\).

Returns
\(\delta\,R_l^0\)

Definition at line 894 of file StandardModel.h.

895 {
896 return delR0l;
897 }

◆ getDelSigma0H()

const double StandardModel::getDelSigma0H ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\).

Returns
\(\delta\,\sigma_{Hadron}^0\) in nb

Definition at line 884 of file StandardModel.h.

885 {
886 return delsigma0H;
887 }

◆ getDelSin2th_b()

const double StandardModel::getDelSin2th_b ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\).

Returns
\(\delta\sin^2\theta_{\rm eff}^{b}\)

Definition at line 864 of file StandardModel.h.

865 {
866 return delSin2th_b;
867 }

◆ getDelSin2th_l()

const double StandardModel::getDelSin2th_l ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\).

Returns
\(\delta\sin^2\theta_{\rm eff}^{\rm lept}\)

Definition at line 842 of file StandardModel.h.

843 {
844 return delSin2th_l;
845 }

◆ getDelSin2th_q()

const double StandardModel::getDelSin2th_q ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\).

Returns
\(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\)

Definition at line 853 of file StandardModel.h.

854 {
855 return delSin2th_q;
856 }

◆ getFlagKappaZ()

const std::string StandardModel::getFlagKappaZ ( ) const
inline

A method to retrieve the model flag KappaZ.

See StandardModelFlags for detail.

Returns

Definition at line 726 of file StandardModel.h.

727 {
728 return FlagKappaZ;
729 }

◆ getFlagMw()

const std::string StandardModel::getFlagMw ( ) const
inline

A method to retrieve the model flag Mw.

See StandardModelFlags for detail.

Returns

Definition at line 706 of file StandardModel.h.

707 {
708 return FlagMw;
709 }

◆ getFlagRhoZ()

const std::string StandardModel::getFlagRhoZ ( ) const
inline

A method to retrieve the model flag RhoZ.

See StandardModelFlags for detail.

Returns

Definition at line 716 of file StandardModel.h.

717 {
718 return FlagRhoZ;
719 }

◆ getFlavour()

const Flavour & StandardModel::getFlavour ( ) const
inline

Definition at line 1065 of file StandardModel.h.

1066 {
1067 return SMFlavour;
1068 }

◆ getGF()

const double StandardModel::getGF ( ) const
inline

A get method to retrieve the Fermi constant \(G_\mu\).

Returns
\(G_\mu\) in \({\rm GeV}^{-2}\)

Definition at line 792 of file StandardModel.h.

793 {
794 return GF;
795 }

◆ getIntegrand_AFBnumeratorWithISR_bottom133()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133 ( double  x) const
protected

Definition at line 9540 of file StandardModel/src/StandardModel.cpp.

9541{
9542 double s = 133. * 133.;
9544}
const double Integrand_AFBnumeratorWithISR_q(double x, const QCD::quark q_flavor, const double s) const

◆ getIntegrand_AFBnumeratorWithISR_bottom167()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167 ( double  x) const
protected

Definition at line 9546 of file StandardModel/src/StandardModel.cpp.

9547{
9548 double s = 167. * 167.;
9550}

◆ getIntegrand_AFBnumeratorWithISR_bottom172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom172 ( double  x) const
protected

Definition at line 9552 of file StandardModel/src/StandardModel.cpp.

9553{
9554 double s = 172. * 172.;
9556}

◆ getIntegrand_AFBnumeratorWithISR_bottom183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183 ( double  x) const
protected

Definition at line 9558 of file StandardModel/src/StandardModel.cpp.

9559{
9560 double s = 183. * 183.;
9562}

◆ getIntegrand_AFBnumeratorWithISR_bottom189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189 ( double  x) const
protected

Definition at line 9564 of file StandardModel/src/StandardModel.cpp.

9565{
9566 double s = 189. * 189.;
9568}

◆ getIntegrand_AFBnumeratorWithISR_bottom192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192 ( double  x) const
protected

Definition at line 9570 of file StandardModel/src/StandardModel.cpp.

9571{
9572 double s = 192. * 192.;
9574}

◆ getIntegrand_AFBnumeratorWithISR_bottom196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196 ( double  x) const
protected

Definition at line 9576 of file StandardModel/src/StandardModel.cpp.

9577{
9578 double s = 196. * 196.;
9580}

◆ getIntegrand_AFBnumeratorWithISR_bottom200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200 ( double  x) const
protected

Definition at line 9582 of file StandardModel/src/StandardModel.cpp.

9583{
9584 double s = 200. * 200.;
9586}

◆ getIntegrand_AFBnumeratorWithISR_bottom202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202 ( double  x) const
protected

Definition at line 9588 of file StandardModel/src/StandardModel.cpp.

9589{
9590 double s = 202. * 202.;
9592}

◆ getIntegrand_AFBnumeratorWithISR_bottom205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205 ( double  x) const
protected

Definition at line 9594 of file StandardModel/src/StandardModel.cpp.

9595{
9596 double s = 205. * 205.;
9598}

◆ getIntegrand_AFBnumeratorWithISR_bottom207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207 ( double  x) const
protected

Definition at line 9600 of file StandardModel/src/StandardModel.cpp.

9601{
9602 double s = 207. * 207.;
9604}

◆ getIntegrand_AFBnumeratorWithISR_charm133()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm133 ( double  x) const
protected

Definition at line 9471 of file StandardModel/src/StandardModel.cpp.

9472{
9473 double s = 133. * 133.;
9475}

◆ getIntegrand_AFBnumeratorWithISR_charm167()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm167 ( double  x) const
protected

Definition at line 9477 of file StandardModel/src/StandardModel.cpp.

9478{
9479 double s = 167. * 167.;
9481}

◆ getIntegrand_AFBnumeratorWithISR_charm172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm172 ( double  x) const
protected

Definition at line 9483 of file StandardModel/src/StandardModel.cpp.

9484{
9485 double s = 172. * 172.;
9487}

◆ getIntegrand_AFBnumeratorWithISR_charm183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm183 ( double  x) const
protected

Definition at line 9489 of file StandardModel/src/StandardModel.cpp.

9490{
9491 double s = 183. * 183.;
9493}

◆ getIntegrand_AFBnumeratorWithISR_charm189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm189 ( double  x) const
protected

Definition at line 9495 of file StandardModel/src/StandardModel.cpp.

9496{
9497 double s = 189. * 189.;
9499}

◆ getIntegrand_AFBnumeratorWithISR_charm192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm192 ( double  x) const
protected

Definition at line 9501 of file StandardModel/src/StandardModel.cpp.

9502{
9503 double s = 192. * 192.;
9505}

◆ getIntegrand_AFBnumeratorWithISR_charm196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm196 ( double  x) const
protected

Definition at line 9507 of file StandardModel/src/StandardModel.cpp.

9508{
9509 double s = 196. * 196.;
9511}

◆ getIntegrand_AFBnumeratorWithISR_charm200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm200 ( double  x) const
protected

Definition at line 9513 of file StandardModel/src/StandardModel.cpp.

9514{
9515 double s = 200. * 200.;
9517}

◆ getIntegrand_AFBnumeratorWithISR_charm202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm202 ( double  x) const
protected

Definition at line 9519 of file StandardModel/src/StandardModel.cpp.

9520{
9521 double s = 202. * 202.;
9523}

◆ getIntegrand_AFBnumeratorWithISR_charm205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm205 ( double  x) const
protected

Definition at line 9525 of file StandardModel/src/StandardModel.cpp.

9526{
9527 double s = 205. * 205.;
9529}

◆ getIntegrand_AFBnumeratorWithISR_charm207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm207 ( double  x) const
protected

Definition at line 9531 of file StandardModel/src/StandardModel.cpp.

9532{
9533 double s = 207. * 207.;
9535}

◆ getIntegrand_AFBnumeratorWithISR_mu130()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu130 ( double  x) const
protected

Definition at line 9309 of file StandardModel/src/StandardModel.cpp.

9310{
9311 double s = 130. * 130.;
9313}
lepton
An enum type for leptons.
Definition: QCD.h:310
const double Integrand_AFBnumeratorWithISR_l(double x, const QCD::lepton l_flavor, const double s) const

◆ getIntegrand_AFBnumeratorWithISR_mu136()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu136 ( double  x) const
protected

Definition at line 9315 of file StandardModel/src/StandardModel.cpp.

9316{
9317 double s = 136. * 136.;
9319}

◆ getIntegrand_AFBnumeratorWithISR_mu161()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu161 ( double  x) const
protected

Definition at line 9321 of file StandardModel/src/StandardModel.cpp.

9322{
9323 double s = 161. * 161.;
9325}

◆ getIntegrand_AFBnumeratorWithISR_mu172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu172 ( double  x) const
protected

Definition at line 9327 of file StandardModel/src/StandardModel.cpp.

9328{
9329 double s = 172. * 172.;
9331}

◆ getIntegrand_AFBnumeratorWithISR_mu183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu183 ( double  x) const
protected

Definition at line 9333 of file StandardModel/src/StandardModel.cpp.

9334{
9335 double s = 183. * 183.;
9337}

◆ getIntegrand_AFBnumeratorWithISR_mu189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu189 ( double  x) const
protected

Definition at line 9339 of file StandardModel/src/StandardModel.cpp.

9340{
9341 double s = 189. * 189.;
9343}

◆ getIntegrand_AFBnumeratorWithISR_mu192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu192 ( double  x) const
protected

Definition at line 9345 of file StandardModel/src/StandardModel.cpp.

9346{
9347 double s = 192. * 192.;
9349}

◆ getIntegrand_AFBnumeratorWithISR_mu196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu196 ( double  x) const
protected

Definition at line 9351 of file StandardModel/src/StandardModel.cpp.

9352{
9353 double s = 196. * 196.;
9355}

◆ getIntegrand_AFBnumeratorWithISR_mu200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu200 ( double  x) const
protected

Definition at line 9357 of file StandardModel/src/StandardModel.cpp.

9358{
9359 double s = 200. * 200.;
9361}

◆ getIntegrand_AFBnumeratorWithISR_mu202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu202 ( double  x) const
protected

Definition at line 9363 of file StandardModel/src/StandardModel.cpp.

9364{
9365 double s = 202. * 202.;
9367}

◆ getIntegrand_AFBnumeratorWithISR_mu205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu205 ( double  x) const
protected

Definition at line 9369 of file StandardModel/src/StandardModel.cpp.

9370{
9371 double s = 205. * 205.;
9373}

◆ getIntegrand_AFBnumeratorWithISR_mu207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu207 ( double  x) const
protected

Definition at line 9375 of file StandardModel/src/StandardModel.cpp.

9376{
9377 double s = 207. * 207.;
9379}

◆ getIntegrand_AFBnumeratorWithISR_tau130()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau130 ( double  x) const
protected

Definition at line 9382 of file StandardModel/src/StandardModel.cpp.

9383{
9384 double s = 130. * 130.;
9386}

◆ getIntegrand_AFBnumeratorWithISR_tau136()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau136 ( double  x) const
protected

Definition at line 9388 of file StandardModel/src/StandardModel.cpp.

9389{
9390 double s = 136. * 136.;
9392}

◆ getIntegrand_AFBnumeratorWithISR_tau161()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau161 ( double  x) const
protected

Definition at line 9394 of file StandardModel/src/StandardModel.cpp.

9395{
9396 double s = 161. * 161.;
9398}

◆ getIntegrand_AFBnumeratorWithISR_tau172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau172 ( double  x) const
protected

Definition at line 9400 of file StandardModel/src/StandardModel.cpp.

9401{
9402 double s = 172. * 172.;
9404}

◆ getIntegrand_AFBnumeratorWithISR_tau183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau183 ( double  x) const
protected

Definition at line 9406 of file StandardModel/src/StandardModel.cpp.

9407{
9408 double s = 183. * 183.;
9410}

◆ getIntegrand_AFBnumeratorWithISR_tau189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau189 ( double  x) const
protected

Definition at line 9412 of file StandardModel/src/StandardModel.cpp.

9413{
9414 double s = 189. * 189.;
9416}

◆ getIntegrand_AFBnumeratorWithISR_tau192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau192 ( double  x) const
protected

Definition at line 9418 of file StandardModel/src/StandardModel.cpp.

9419{
9420 double s = 192. * 192.;
9422}

◆ getIntegrand_AFBnumeratorWithISR_tau196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau196 ( double  x) const
protected

Definition at line 9424 of file StandardModel/src/StandardModel.cpp.

9425{
9426 double s = 196. * 196.;
9428}

◆ getIntegrand_AFBnumeratorWithISR_tau200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau200 ( double  x) const
protected

Definition at line 9430 of file StandardModel/src/StandardModel.cpp.

9431{
9432 double s = 200. * 200.;
9434}

◆ getIntegrand_AFBnumeratorWithISR_tau202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau202 ( double  x) const
protected

Definition at line 9436 of file StandardModel/src/StandardModel.cpp.

9437{
9438 double s = 202. * 202.;
9440}

◆ getIntegrand_AFBnumeratorWithISR_tau205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau205 ( double  x) const
protected

Definition at line 9442 of file StandardModel/src/StandardModel.cpp.

9443{
9444 double s = 205. * 205.;
9446}

◆ getIntegrand_AFBnumeratorWithISR_tau207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau207 ( double  x) const
protected

Definition at line 9448 of file StandardModel/src/StandardModel.cpp.

9449{
9450 double s = 207. * 207.;
9452}

◆ getIntegrand_dsigmaBox_bottom130()

const double StandardModel::getIntegrand_dsigmaBox_bottom130 ( double  x) const
protected

Definition at line 9201 of file StandardModel/src/StandardModel.cpp.

9202{
9203 double s = 130. * 130.;
9205}
const double Integrand_dsigmaBox_q(double cosTheta, const QCD::quark q_flavor, const double s) const

◆ getIntegrand_dsigmaBox_bottom133()

const double StandardModel::getIntegrand_dsigmaBox_bottom133 ( double  x) const
protected

Definition at line 9207 of file StandardModel/src/StandardModel.cpp.

9208{
9209 double s = 133. * 133.;
9211}

◆ getIntegrand_dsigmaBox_bottom136()

const double StandardModel::getIntegrand_dsigmaBox_bottom136 ( double  x) const
protected

Definition at line 9213 of file StandardModel/src/StandardModel.cpp.

9214{
9215 double s = 136. * 136.;
9217}

◆ getIntegrand_dsigmaBox_bottom161()

const double StandardModel::getIntegrand_dsigmaBox_bottom161 ( double  x) const
protected

Definition at line 9219 of file StandardModel/src/StandardModel.cpp.

9220{
9221 double s = 161. * 161.;
9223}

◆ getIntegrand_dsigmaBox_bottom167()

const double StandardModel::getIntegrand_dsigmaBox_bottom167 ( double  x) const
protected

Definition at line 9225 of file StandardModel/src/StandardModel.cpp.

9226{
9227 double s = 167. * 167.;
9229}

◆ getIntegrand_dsigmaBox_bottom172()

const double StandardModel::getIntegrand_dsigmaBox_bottom172 ( double  x) const
protected

Definition at line 9231 of file StandardModel/src/StandardModel.cpp.

9232{
9233 double s = 172. * 172.;
9235}

◆ getIntegrand_dsigmaBox_bottom183()

const double StandardModel::getIntegrand_dsigmaBox_bottom183 ( double  x) const
protected

Definition at line 9237 of file StandardModel/src/StandardModel.cpp.

9238{
9239 double s = 183. * 183.;
9241}

◆ getIntegrand_dsigmaBox_bottom189()

const double StandardModel::getIntegrand_dsigmaBox_bottom189 ( double  x) const
protected

Definition at line 9243 of file StandardModel/src/StandardModel.cpp.

9244{
9245 double s = 189. * 189.;
9247}

◆ getIntegrand_dsigmaBox_bottom192()

const double StandardModel::getIntegrand_dsigmaBox_bottom192 ( double  x) const
protected

Definition at line 9249 of file StandardModel/src/StandardModel.cpp.

9250{
9251 double s = 192. * 192.;
9253}

◆ getIntegrand_dsigmaBox_bottom196()

const double StandardModel::getIntegrand_dsigmaBox_bottom196 ( double  x) const
protected

Definition at line 9255 of file StandardModel/src/StandardModel.cpp.

9256{
9257 double s = 196. * 196.;
9259}

◆ getIntegrand_dsigmaBox_bottom200()

const double StandardModel::getIntegrand_dsigmaBox_bottom200 ( double  x) const
protected

Definition at line 9261 of file StandardModel/src/StandardModel.cpp.

9262{
9263 double s = 200. * 200.;
9265}

◆ getIntegrand_dsigmaBox_bottom202()

const double StandardModel::getIntegrand_dsigmaBox_bottom202 ( double  x) const
protected

Definition at line 9267 of file StandardModel/src/StandardModel.cpp.

9268{
9269 double s = 202. * 202.;
9271}

◆ getIntegrand_dsigmaBox_bottom205()

const double StandardModel::getIntegrand_dsigmaBox_bottom205 ( double  x) const
protected

Definition at line 9273 of file StandardModel/src/StandardModel.cpp.

9274{
9275 double s = 205. * 205.;
9277}

◆ getIntegrand_dsigmaBox_bottom207()

const double StandardModel::getIntegrand_dsigmaBox_bottom207 ( double  x) const
protected

Definition at line 9279 of file StandardModel/src/StandardModel.cpp.

9280{
9281 double s = 207. * 207.;
9283}

◆ getIntegrand_dsigmaBox_charm130()

const double StandardModel::getIntegrand_dsigmaBox_charm130 ( double  x) const
protected

Definition at line 9023 of file StandardModel/src/StandardModel.cpp.

9024{
9025 double s = 130. * 130.;
9026 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9027}

◆ getIntegrand_dsigmaBox_charm133()

const double StandardModel::getIntegrand_dsigmaBox_charm133 ( double  x) const
protected

Definition at line 9029 of file StandardModel/src/StandardModel.cpp.

9030{
9031 double s = 133. * 133.;
9032 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9033}

◆ getIntegrand_dsigmaBox_charm136()

const double StandardModel::getIntegrand_dsigmaBox_charm136 ( double  x) const
protected

Definition at line 9035 of file StandardModel/src/StandardModel.cpp.

9036{
9037 double s = 136. * 136.;
9038 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9039}

◆ getIntegrand_dsigmaBox_charm161()

const double StandardModel::getIntegrand_dsigmaBox_charm161 ( double  x) const
protected

Definition at line 9041 of file StandardModel/src/StandardModel.cpp.

9042{
9043 double s = 161. * 161.;
9044 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9045}

◆ getIntegrand_dsigmaBox_charm167()

const double StandardModel::getIntegrand_dsigmaBox_charm167 ( double  x) const
protected

Definition at line 9047 of file StandardModel/src/StandardModel.cpp.

9048{
9049 double s = 167. * 167.;
9050 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9051}

◆ getIntegrand_dsigmaBox_charm172()

const double StandardModel::getIntegrand_dsigmaBox_charm172 ( double  x) const
protected

Definition at line 9053 of file StandardModel/src/StandardModel.cpp.

9054{
9055 double s = 172. * 172.;
9056 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9057}

◆ getIntegrand_dsigmaBox_charm183()

const double StandardModel::getIntegrand_dsigmaBox_charm183 ( double  x) const
protected

Definition at line 9059 of file StandardModel/src/StandardModel.cpp.

9060{
9061 double s = 183. * 183.;
9062 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9063}

◆ getIntegrand_dsigmaBox_charm189()

const double StandardModel::getIntegrand_dsigmaBox_charm189 ( double  x) const
protected

Definition at line 9065 of file StandardModel/src/StandardModel.cpp.

9066{
9067 double s = 189. * 189.;
9068 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9069}

◆ getIntegrand_dsigmaBox_charm192()

const double StandardModel::getIntegrand_dsigmaBox_charm192 ( double  x) const
protected

Definition at line 9071 of file StandardModel/src/StandardModel.cpp.

9072{
9073 double s = 192. * 192.;
9074 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9075}

◆ getIntegrand_dsigmaBox_charm196()

const double StandardModel::getIntegrand_dsigmaBox_charm196 ( double  x) const
protected

Definition at line 9077 of file StandardModel/src/StandardModel.cpp.

9078{
9079 double s = 196. * 196.;
9080 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9081}

◆ getIntegrand_dsigmaBox_charm200()

const double StandardModel::getIntegrand_dsigmaBox_charm200 ( double  x) const
protected

Definition at line 9083 of file StandardModel/src/StandardModel.cpp.

9084{
9085 double s = 200. * 200.;
9086 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9087}

◆ getIntegrand_dsigmaBox_charm202()

const double StandardModel::getIntegrand_dsigmaBox_charm202 ( double  x) const
protected

Definition at line 9089 of file StandardModel/src/StandardModel.cpp.

9090{
9091 double s = 202. * 202.;
9092 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9093}

◆ getIntegrand_dsigmaBox_charm205()

const double StandardModel::getIntegrand_dsigmaBox_charm205 ( double  x) const
protected

Definition at line 9095 of file StandardModel/src/StandardModel.cpp.

9096{
9097 double s = 205. * 205.;
9098 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9099}

◆ getIntegrand_dsigmaBox_charm207()

const double StandardModel::getIntegrand_dsigmaBox_charm207 ( double  x) const
protected

Definition at line 9101 of file StandardModel/src/StandardModel.cpp.

9102{
9103 double s = 207. * 207.;
9104 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9105}

◆ getIntegrand_dsigmaBox_down130()

const double StandardModel::getIntegrand_dsigmaBox_down130 ( double  x) const
protected

Definition at line 8935 of file StandardModel/src/StandardModel.cpp.

8936{
8937 double s = 130. * 130.;
8938 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8939}

◆ getIntegrand_dsigmaBox_down133()

const double StandardModel::getIntegrand_dsigmaBox_down133 ( double  x) const
protected

Definition at line 8941 of file StandardModel/src/StandardModel.cpp.

8942{
8943 double s = 133. * 133.;
8944 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8945}

◆ getIntegrand_dsigmaBox_down136()

const double StandardModel::getIntegrand_dsigmaBox_down136 ( double  x) const
protected

Definition at line 8947 of file StandardModel/src/StandardModel.cpp.

8948{
8949 double s = 136. * 136.;
8950 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8951}

◆ getIntegrand_dsigmaBox_down161()

const double StandardModel::getIntegrand_dsigmaBox_down161 ( double  x) const
protected

Definition at line 8953 of file StandardModel/src/StandardModel.cpp.

8954{
8955 double s = 161. * 161.;
8956 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8957}

◆ getIntegrand_dsigmaBox_down167()

const double StandardModel::getIntegrand_dsigmaBox_down167 ( double  x) const
protected

Definition at line 8959 of file StandardModel/src/StandardModel.cpp.

8960{
8961 double s = 167. * 167.;
8962 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8963}

◆ getIntegrand_dsigmaBox_down172()

const double StandardModel::getIntegrand_dsigmaBox_down172 ( double  x) const
protected

Definition at line 8965 of file StandardModel/src/StandardModel.cpp.

8966{
8967 double s = 172. * 172.;
8968 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8969}

◆ getIntegrand_dsigmaBox_down183()

const double StandardModel::getIntegrand_dsigmaBox_down183 ( double  x) const
protected

Definition at line 8971 of file StandardModel/src/StandardModel.cpp.

8972{
8973 double s = 183. * 183.;
8974 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8975}

◆ getIntegrand_dsigmaBox_down189()

const double StandardModel::getIntegrand_dsigmaBox_down189 ( double  x) const
protected

Definition at line 8977 of file StandardModel/src/StandardModel.cpp.

8978{
8979 double s = 189. * 189.;
8980 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8981}

◆ getIntegrand_dsigmaBox_down192()

const double StandardModel::getIntegrand_dsigmaBox_down192 ( double  x) const
protected

Definition at line 8983 of file StandardModel/src/StandardModel.cpp.

8984{
8985 double s = 192. * 192.;
8986 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8987}

◆ getIntegrand_dsigmaBox_down196()

const double StandardModel::getIntegrand_dsigmaBox_down196 ( double  x) const
protected

Definition at line 8989 of file StandardModel/src/StandardModel.cpp.

8990{
8991 double s = 196. * 196.;
8992 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8993}

◆ getIntegrand_dsigmaBox_down200()

const double StandardModel::getIntegrand_dsigmaBox_down200 ( double  x) const
protected

Definition at line 8995 of file StandardModel/src/StandardModel.cpp.

8996{
8997 double s = 200. * 200.;
8998 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8999}

◆ getIntegrand_dsigmaBox_down202()

const double StandardModel::getIntegrand_dsigmaBox_down202 ( double  x) const
protected

Definition at line 9001 of file StandardModel/src/StandardModel.cpp.

9002{
9003 double s = 202. * 202.;
9004 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9005}

◆ getIntegrand_dsigmaBox_down205()

const double StandardModel::getIntegrand_dsigmaBox_down205 ( double  x) const
protected

Definition at line 9007 of file StandardModel/src/StandardModel.cpp.

9008{
9009 double s = 205. * 205.;
9010 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9011}

◆ getIntegrand_dsigmaBox_down207()

const double StandardModel::getIntegrand_dsigmaBox_down207 ( double  x) const
protected

Definition at line 9013 of file StandardModel/src/StandardModel.cpp.

9014{
9015 double s = 207. * 207.;
9016 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9017}

◆ getIntegrand_dsigmaBox_mu130()

const double StandardModel::getIntegrand_dsigmaBox_mu130 ( double  x) const
protected

Definition at line 8683 of file StandardModel/src/StandardModel.cpp.

8684{
8685 double s = 130. * 130.;
8686 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8687}
const double Integrand_dsigmaBox_l(double cosTheta, const QCD::lepton l_flavor, const double s) const

◆ getIntegrand_dsigmaBox_mu133()

const double StandardModel::getIntegrand_dsigmaBox_mu133 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_mu136()

const double StandardModel::getIntegrand_dsigmaBox_mu136 ( double  x) const
protected

Definition at line 8689 of file StandardModel/src/StandardModel.cpp.

8690{
8691 double s = 136. * 136.;
8692 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8693}

◆ getIntegrand_dsigmaBox_mu161()

const double StandardModel::getIntegrand_dsigmaBox_mu161 ( double  x) const
protected

Definition at line 8695 of file StandardModel/src/StandardModel.cpp.

8696{
8697 double s = 161. * 161.;
8698 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8699}

◆ getIntegrand_dsigmaBox_mu167()

const double StandardModel::getIntegrand_dsigmaBox_mu167 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_mu172()

const double StandardModel::getIntegrand_dsigmaBox_mu172 ( double  x) const
protected

Definition at line 8701 of file StandardModel/src/StandardModel.cpp.

8702{
8703 double s = 172. * 172.;
8704 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8705}

◆ getIntegrand_dsigmaBox_mu183()

const double StandardModel::getIntegrand_dsigmaBox_mu183 ( double  x) const
protected

Definition at line 8707 of file StandardModel/src/StandardModel.cpp.

8708{
8709 double s = 183. * 183.;
8710 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8711}

◆ getIntegrand_dsigmaBox_mu189()

const double StandardModel::getIntegrand_dsigmaBox_mu189 ( double  x) const
protected

Definition at line 8713 of file StandardModel/src/StandardModel.cpp.

8714{
8715 double s = 189. * 189.;
8716 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8717}

◆ getIntegrand_dsigmaBox_mu192()

const double StandardModel::getIntegrand_dsigmaBox_mu192 ( double  x) const
protected

Definition at line 8719 of file StandardModel/src/StandardModel.cpp.

8720{
8721 double s = 192. * 192.;
8722 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8723}

◆ getIntegrand_dsigmaBox_mu196()

const double StandardModel::getIntegrand_dsigmaBox_mu196 ( double  x) const
protected

Definition at line 8725 of file StandardModel/src/StandardModel.cpp.

8726{
8727 double s = 196. * 196.;
8728 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8729}

◆ getIntegrand_dsigmaBox_mu200()

const double StandardModel::getIntegrand_dsigmaBox_mu200 ( double  x) const
protected

Definition at line 8731 of file StandardModel/src/StandardModel.cpp.

8732{
8733 double s = 200. * 200.;
8734 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8735}

◆ getIntegrand_dsigmaBox_mu202()

const double StandardModel::getIntegrand_dsigmaBox_mu202 ( double  x) const
protected

Definition at line 8737 of file StandardModel/src/StandardModel.cpp.

8738{
8739 double s = 202. * 202.;
8740 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8741}

◆ getIntegrand_dsigmaBox_mu205()

const double StandardModel::getIntegrand_dsigmaBox_mu205 ( double  x) const
protected

Definition at line 8743 of file StandardModel/src/StandardModel.cpp.

8744{
8745 double s = 205. * 205.;
8746 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8747}

◆ getIntegrand_dsigmaBox_mu207()

const double StandardModel::getIntegrand_dsigmaBox_mu207 ( double  x) const
protected

Definition at line 8749 of file StandardModel/src/StandardModel.cpp.

8750{
8751 double s = 207. * 207.;
8752 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8753}

◆ getIntegrand_dsigmaBox_strange130()

const double StandardModel::getIntegrand_dsigmaBox_strange130 ( double  x) const
protected

Definition at line 9111 of file StandardModel/src/StandardModel.cpp.

9112{
9113 double s = 130. * 130.;
9115}

◆ getIntegrand_dsigmaBox_strange133()

const double StandardModel::getIntegrand_dsigmaBox_strange133 ( double  x) const
protected

Definition at line 9117 of file StandardModel/src/StandardModel.cpp.

9118{
9119 double s = 133. * 133.;
9121}

◆ getIntegrand_dsigmaBox_strange136()

const double StandardModel::getIntegrand_dsigmaBox_strange136 ( double  x) const
protected

Definition at line 9123 of file StandardModel/src/StandardModel.cpp.

9124{
9125 double s = 136. * 136.;
9127}

◆ getIntegrand_dsigmaBox_strange161()

const double StandardModel::getIntegrand_dsigmaBox_strange161 ( double  x) const
protected

Definition at line 9129 of file StandardModel/src/StandardModel.cpp.

9130{
9131 double s = 161. * 161.;
9133}

◆ getIntegrand_dsigmaBox_strange167()

const double StandardModel::getIntegrand_dsigmaBox_strange167 ( double  x) const
protected

Definition at line 9135 of file StandardModel/src/StandardModel.cpp.

9136{
9137 double s = 167. * 167.;
9139}

◆ getIntegrand_dsigmaBox_strange172()

const double StandardModel::getIntegrand_dsigmaBox_strange172 ( double  x) const
protected

Definition at line 9143 of file StandardModel/src/StandardModel.cpp.

9144{
9145 double s = 172. * 172.;
9147}

◆ getIntegrand_dsigmaBox_strange183()

const double StandardModel::getIntegrand_dsigmaBox_strange183 ( double  x) const
protected

Definition at line 9149 of file StandardModel/src/StandardModel.cpp.

9150{
9151 double s = 183. * 183.;
9153}

◆ getIntegrand_dsigmaBox_strange189()

const double StandardModel::getIntegrand_dsigmaBox_strange189 ( double  x) const
protected

Definition at line 9155 of file StandardModel/src/StandardModel.cpp.

9156{
9157 double s = 189. * 189.;
9159}

◆ getIntegrand_dsigmaBox_strange192()

const double StandardModel::getIntegrand_dsigmaBox_strange192 ( double  x) const
protected

Definition at line 9161 of file StandardModel/src/StandardModel.cpp.

9162{
9163 double s = 192. * 192.;
9165}

◆ getIntegrand_dsigmaBox_strange196()

const double StandardModel::getIntegrand_dsigmaBox_strange196 ( double  x) const
protected

Definition at line 9167 of file StandardModel/src/StandardModel.cpp.

9168{
9169 double s = 196. * 196.;
9171}

◆ getIntegrand_dsigmaBox_strange200()

const double StandardModel::getIntegrand_dsigmaBox_strange200 ( double  x) const
protected

Definition at line 9173 of file StandardModel/src/StandardModel.cpp.

9174{
9175 double s = 200. * 200.;
9177}

◆ getIntegrand_dsigmaBox_strange202()

const double StandardModel::getIntegrand_dsigmaBox_strange202 ( double  x) const
protected

Definition at line 9179 of file StandardModel/src/StandardModel.cpp.

9180{
9181 double s = 202. * 202.;
9183}

◆ getIntegrand_dsigmaBox_strange205()

const double StandardModel::getIntegrand_dsigmaBox_strange205 ( double  x) const
protected

Definition at line 9185 of file StandardModel/src/StandardModel.cpp.

9186{
9187 double s = 205. * 205.;
9189}

◆ getIntegrand_dsigmaBox_strange207()

const double StandardModel::getIntegrand_dsigmaBox_strange207 ( double  x) const
protected

Definition at line 9191 of file StandardModel/src/StandardModel.cpp.

9192{
9193 double s = 207. * 207.;
9195}

◆ getIntegrand_dsigmaBox_tau130()

const double StandardModel::getIntegrand_dsigmaBox_tau130 ( double  x) const
protected

Definition at line 8759 of file StandardModel/src/StandardModel.cpp.

8760{
8761 double s = 130. * 130.;
8762 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8763}

◆ getIntegrand_dsigmaBox_tau133()

const double StandardModel::getIntegrand_dsigmaBox_tau133 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_tau136()

const double StandardModel::getIntegrand_dsigmaBox_tau136 ( double  x) const
protected

Definition at line 8765 of file StandardModel/src/StandardModel.cpp.

8766{
8767 double s = 136. * 136.;
8768 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8769}

◆ getIntegrand_dsigmaBox_tau161()

const double StandardModel::getIntegrand_dsigmaBox_tau161 ( double  x) const
protected

Definition at line 8771 of file StandardModel/src/StandardModel.cpp.

8772{
8773 double s = 161. * 161.;
8774 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8775}

◆ getIntegrand_dsigmaBox_tau167()

const double StandardModel::getIntegrand_dsigmaBox_tau167 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_tau172()

const double StandardModel::getIntegrand_dsigmaBox_tau172 ( double  x) const
protected

Definition at line 8777 of file StandardModel/src/StandardModel.cpp.

8778{
8779 double s = 172. * 172.;
8780 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8781}

◆ getIntegrand_dsigmaBox_tau183()

const double StandardModel::getIntegrand_dsigmaBox_tau183 ( double  x) const
protected

Definition at line 8783 of file StandardModel/src/StandardModel.cpp.

8784{
8785 double s = 183. * 183.;
8786 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8787}

◆ getIntegrand_dsigmaBox_tau189()

const double StandardModel::getIntegrand_dsigmaBox_tau189 ( double  x) const
protected

Definition at line 8789 of file StandardModel/src/StandardModel.cpp.

8790{
8791 double s = 189. * 189.;
8792 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8793}

◆ getIntegrand_dsigmaBox_tau192()

const double StandardModel::getIntegrand_dsigmaBox_tau192 ( double  x) const
protected

Definition at line 8795 of file StandardModel/src/StandardModel.cpp.

8796{
8797 double s = 192. * 192.;
8798 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8799}

◆ getIntegrand_dsigmaBox_tau196()

const double StandardModel::getIntegrand_dsigmaBox_tau196 ( double  x) const
protected

Definition at line 8801 of file StandardModel/src/StandardModel.cpp.

8802{
8803 double s = 196. * 196.;
8804 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8805}

◆ getIntegrand_dsigmaBox_tau200()

const double StandardModel::getIntegrand_dsigmaBox_tau200 ( double  x) const
protected

Definition at line 8807 of file StandardModel/src/StandardModel.cpp.

8808{
8809 double s = 200. * 200.;
8810 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8811}

◆ getIntegrand_dsigmaBox_tau202()

const double StandardModel::getIntegrand_dsigmaBox_tau202 ( double  x) const
protected

Definition at line 8813 of file StandardModel/src/StandardModel.cpp.

8814{
8815 double s = 202. * 202.;
8816 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8817}

◆ getIntegrand_dsigmaBox_tau205()

const double StandardModel::getIntegrand_dsigmaBox_tau205 ( double  x) const
protected

Definition at line 8819 of file StandardModel/src/StandardModel.cpp.

8820{
8821 double s = 205. * 205.;
8822 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8823}

◆ getIntegrand_dsigmaBox_tau207()

const double StandardModel::getIntegrand_dsigmaBox_tau207 ( double  x) const
protected

Definition at line 8825 of file StandardModel/src/StandardModel.cpp.

8826{
8827 double s = 207. * 207.;
8828 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8829}

◆ getIntegrand_dsigmaBox_up130()

const double StandardModel::getIntegrand_dsigmaBox_up130 ( double  x) const
protected

Definition at line 8848 of file StandardModel/src/StandardModel.cpp.

8849{
8850 double s = 130. * 130.;
8851 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8852}

◆ getIntegrand_dsigmaBox_up133()

const double StandardModel::getIntegrand_dsigmaBox_up133 ( double  x) const
protected

Definition at line 8854 of file StandardModel/src/StandardModel.cpp.

8855{
8856 double s = 133. * 133.;
8857 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8858}

◆ getIntegrand_dsigmaBox_up136()

const double StandardModel::getIntegrand_dsigmaBox_up136 ( double  x) const
protected

Definition at line 8860 of file StandardModel/src/StandardModel.cpp.

8861{
8862 double s = 136. * 136.;
8863 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8864}

◆ getIntegrand_dsigmaBox_up161()

const double StandardModel::getIntegrand_dsigmaBox_up161 ( double  x) const
protected

Definition at line 8866 of file StandardModel/src/StandardModel.cpp.

8867{
8868 double s = 161. * 161.;
8869 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8870}

◆ getIntegrand_dsigmaBox_up167()

const double StandardModel::getIntegrand_dsigmaBox_up167 ( double  x) const
protected

Definition at line 8872 of file StandardModel/src/StandardModel.cpp.

8873{
8874 double s = 167. * 167.;
8875 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8876}

◆ getIntegrand_dsigmaBox_up172()

const double StandardModel::getIntegrand_dsigmaBox_up172 ( double  x) const
protected

Definition at line 8878 of file StandardModel/src/StandardModel.cpp.

8879{
8880 double s = 172. * 172.;
8881 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8882}

◆ getIntegrand_dsigmaBox_up183()

const double StandardModel::getIntegrand_dsigmaBox_up183 ( double  x) const
protected

Definition at line 8884 of file StandardModel/src/StandardModel.cpp.

8885{
8886 double s = 183. * 183.;
8887 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8888}

◆ getIntegrand_dsigmaBox_up189()

const double StandardModel::getIntegrand_dsigmaBox_up189 ( double  x) const
protected

Definition at line 8890 of file StandardModel/src/StandardModel.cpp.

8891{
8892 double s = 189. * 189.;
8893 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8894}

◆ getIntegrand_dsigmaBox_up192()

const double StandardModel::getIntegrand_dsigmaBox_up192 ( double  x) const
protected

Definition at line 8896 of file StandardModel/src/StandardModel.cpp.

8897{
8898 double s = 192. * 192.;
8899 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8900}

◆ getIntegrand_dsigmaBox_up196()

const double StandardModel::getIntegrand_dsigmaBox_up196 ( double  x) const
protected

Definition at line 8902 of file StandardModel/src/StandardModel.cpp.

8903{
8904 double s = 196. * 196.;
8905 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8906}

◆ getIntegrand_dsigmaBox_up200()

const double StandardModel::getIntegrand_dsigmaBox_up200 ( double  x) const
protected

Definition at line 8908 of file StandardModel/src/StandardModel.cpp.

8909{
8910 double s = 200. * 200.;
8911 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8912}

◆ getIntegrand_dsigmaBox_up202()

const double StandardModel::getIntegrand_dsigmaBox_up202 ( double  x) const
protected

Definition at line 8914 of file StandardModel/src/StandardModel.cpp.

8915{
8916 double s = 202. * 202.;
8917 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8918}

◆ getIntegrand_dsigmaBox_up205()

const double StandardModel::getIntegrand_dsigmaBox_up205 ( double  x) const
protected

Definition at line 8920 of file StandardModel/src/StandardModel.cpp.

8921{
8922 double s = 205. * 205.;
8923 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8924}

◆ getIntegrand_dsigmaBox_up207()

const double StandardModel::getIntegrand_dsigmaBox_up207 ( double  x) const
protected

Definition at line 8926 of file StandardModel/src/StandardModel.cpp.

8927{
8928 double s = 207. * 207.;
8929 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8930}

◆ getIntegrand_sigmaWithISR_bottom130()

const double StandardModel::getIntegrand_sigmaWithISR_bottom130 ( double  x) const
protected

Definition at line 8589 of file StandardModel/src/StandardModel.cpp.

8590{
8591 double s = 130. * 130.;
8593}
const double Integrand_sigmaWithISR_q(double x, const QCD::quark q_flavor, const double s) const

◆ getIntegrand_sigmaWithISR_bottom133()

const double StandardModel::getIntegrand_sigmaWithISR_bottom133 ( double  x) const
protected

Definition at line 8595 of file StandardModel/src/StandardModel.cpp.

8596{
8597 double s = 133. * 133.;
8599}

◆ getIntegrand_sigmaWithISR_bottom136()

const double StandardModel::getIntegrand_sigmaWithISR_bottom136 ( double  x) const
protected

Definition at line 8601 of file StandardModel/src/StandardModel.cpp.

8602{
8603 double s = 136. * 136.;
8605}

◆ getIntegrand_sigmaWithISR_bottom161()

const double StandardModel::getIntegrand_sigmaWithISR_bottom161 ( double  x) const
protected

Definition at line 8607 of file StandardModel/src/StandardModel.cpp.

8608{
8609 double s = 161. * 161.;
8611}

◆ getIntegrand_sigmaWithISR_bottom167()

const double StandardModel::getIntegrand_sigmaWithISR_bottom167 ( double  x) const
protected

Definition at line 8613 of file StandardModel/src/StandardModel.cpp.

8614{
8615 double s = 167. * 167.;
8617}

◆ getIntegrand_sigmaWithISR_bottom172()

const double StandardModel::getIntegrand_sigmaWithISR_bottom172 ( double  x) const
protected

Definition at line 8619 of file StandardModel/src/StandardModel.cpp.

8620{
8621 double s = 172. * 172.;
8623}

◆ getIntegrand_sigmaWithISR_bottom183()

const double StandardModel::getIntegrand_sigmaWithISR_bottom183 ( double  x) const
protected

Definition at line 8625 of file StandardModel/src/StandardModel.cpp.

8626{
8627 double s = 183. * 183.;
8629}

◆ getIntegrand_sigmaWithISR_bottom189()

const double StandardModel::getIntegrand_sigmaWithISR_bottom189 ( double  x) const
protected

Definition at line 8631 of file StandardModel/src/StandardModel.cpp.

8632{
8633 double s = 189. * 189.;
8635}

◆ getIntegrand_sigmaWithISR_bottom192()

const double StandardModel::getIntegrand_sigmaWithISR_bottom192 ( double  x) const
protected

Definition at line 8637 of file StandardModel/src/StandardModel.cpp.

8638{
8639 double s = 192. * 192.;
8641}

◆ getIntegrand_sigmaWithISR_bottom196()

const double StandardModel::getIntegrand_sigmaWithISR_bottom196 ( double  x) const
protected

Definition at line 8643 of file StandardModel/src/StandardModel.cpp.

8644{
8645 double s = 196. * 196.;
8647}

◆ getIntegrand_sigmaWithISR_bottom200()

const double StandardModel::getIntegrand_sigmaWithISR_bottom200 ( double  x) const
protected

Definition at line 8649 of file StandardModel/src/StandardModel.cpp.

8650{
8651 double s = 200. * 200.;
8653}

◆ getIntegrand_sigmaWithISR_bottom202()

const double StandardModel::getIntegrand_sigmaWithISR_bottom202 ( double  x) const
protected

Definition at line 8655 of file StandardModel/src/StandardModel.cpp.

8656{
8657 double s = 202. * 202.;
8659}

◆ getIntegrand_sigmaWithISR_bottom205()

const double StandardModel::getIntegrand_sigmaWithISR_bottom205 ( double  x) const
protected

Definition at line 8661 of file StandardModel/src/StandardModel.cpp.

8662{
8663 double s = 205. * 205.;
8665}

◆ getIntegrand_sigmaWithISR_bottom207()

const double StandardModel::getIntegrand_sigmaWithISR_bottom207 ( double  x) const
protected

Definition at line 8667 of file StandardModel/src/StandardModel.cpp.

8668{
8669 double s = 207. * 207.;
8671}

◆ getIntegrand_sigmaWithISR_charm130()

const double StandardModel::getIntegrand_sigmaWithISR_charm130 ( double  x) const
protected

Definition at line 8413 of file StandardModel/src/StandardModel.cpp.

8414{
8415 double s = 130. * 130.;
8417}

◆ getIntegrand_sigmaWithISR_charm133()

const double StandardModel::getIntegrand_sigmaWithISR_charm133 ( double  x) const
protected

Definition at line 8419 of file StandardModel/src/StandardModel.cpp.

8420{
8421 double s = 133. * 133.;
8423}

◆ getIntegrand_sigmaWithISR_charm136()

const double StandardModel::getIntegrand_sigmaWithISR_charm136 ( double  x) const
protected

Definition at line 8425 of file StandardModel/src/StandardModel.cpp.

8426{
8427 double s = 136. * 136.;
8429}

◆ getIntegrand_sigmaWithISR_charm161()

const double StandardModel::getIntegrand_sigmaWithISR_charm161 ( double  x) const
protected

Definition at line 8431 of file StandardModel/src/StandardModel.cpp.

8432{
8433 double s = 161. * 161.;
8435}

◆ getIntegrand_sigmaWithISR_charm167()

const double StandardModel::getIntegrand_sigmaWithISR_charm167 ( double  x) const
protected

Definition at line 8437 of file StandardModel/src/StandardModel.cpp.

8438{
8439 double s = 167. * 167.;
8441}

◆ getIntegrand_sigmaWithISR_charm172()

const double StandardModel::getIntegrand_sigmaWithISR_charm172 ( double  x) const
protected

Definition at line 8443 of file StandardModel/src/StandardModel.cpp.

8444{
8445 double s = 172. * 172.;
8447}

◆ getIntegrand_sigmaWithISR_charm183()

const double StandardModel::getIntegrand_sigmaWithISR_charm183 ( double  x) const
protected

Definition at line 8449 of file StandardModel/src/StandardModel.cpp.

8450{
8451 double s = 183. * 183.;
8453}

◆ getIntegrand_sigmaWithISR_charm189()

const double StandardModel::getIntegrand_sigmaWithISR_charm189 ( double  x) const
protected

Definition at line 8455 of file StandardModel/src/StandardModel.cpp.

8456{
8457 double s = 189. * 189.;
8459}

◆ getIntegrand_sigmaWithISR_charm192()

const double StandardModel::getIntegrand_sigmaWithISR_charm192 ( double  x) const
protected

Definition at line 8461 of file StandardModel/src/StandardModel.cpp.

8462{
8463 double s = 192. * 192.;
8465}

◆ getIntegrand_sigmaWithISR_charm196()

const double StandardModel::getIntegrand_sigmaWithISR_charm196 ( double  x) const
protected

Definition at line 8467 of file StandardModel/src/StandardModel.cpp.

8468{
8469 double s = 196. * 196.;
8471}

◆ getIntegrand_sigmaWithISR_charm200()

const double StandardModel::getIntegrand_sigmaWithISR_charm200 ( double  x) const
protected

Definition at line 8473 of file StandardModel/src/StandardModel.cpp.

8474{
8475 double s = 200. * 200.;
8477}

◆ getIntegrand_sigmaWithISR_charm202()

const double StandardModel::getIntegrand_sigmaWithISR_charm202 ( double  x) const
protected

Definition at line 8479 of file StandardModel/src/StandardModel.cpp.

8480{
8481 double s = 202. * 202.;
8483}

◆ getIntegrand_sigmaWithISR_charm205()

const double StandardModel::getIntegrand_sigmaWithISR_charm205 ( double  x) const
protected

Definition at line 8485 of file StandardModel/src/StandardModel.cpp.

8486{
8487 double s = 205. * 205.;
8489}

◆ getIntegrand_sigmaWithISR_charm207()

const double StandardModel::getIntegrand_sigmaWithISR_charm207 ( double  x) const
protected

Definition at line 8491 of file StandardModel/src/StandardModel.cpp.

8492{
8493 double s = 207. * 207.;
8495}

◆ getIntegrand_sigmaWithISR_down130()

const double StandardModel::getIntegrand_sigmaWithISR_down130 ( double  x) const
protected

Definition at line 8324 of file StandardModel/src/StandardModel.cpp.

8325{
8326 double s = 130. * 130.;
8328}

◆ getIntegrand_sigmaWithISR_down133()

const double StandardModel::getIntegrand_sigmaWithISR_down133 ( double  x) const
protected

Definition at line 8330 of file StandardModel/src/StandardModel.cpp.

8331{
8332 double s = 133. * 133.;
8334}

◆ getIntegrand_sigmaWithISR_down136()

const double StandardModel::getIntegrand_sigmaWithISR_down136 ( double  x) const
protected

Definition at line 8337 of file StandardModel/src/StandardModel.cpp.

8338{
8339 double s = 136. * 136.;
8341}

◆ getIntegrand_sigmaWithISR_down161()

const double StandardModel::getIntegrand_sigmaWithISR_down161 ( double  x) const
protected

Definition at line 8343 of file StandardModel/src/StandardModel.cpp.

8344{
8345 double s = 161. * 161.;
8347}

◆ getIntegrand_sigmaWithISR_down167()

const double StandardModel::getIntegrand_sigmaWithISR_down167 ( double  x) const
protected

Definition at line 8349 of file StandardModel/src/StandardModel.cpp.

8350{
8351 double s = 167. * 167.;
8353}

◆ getIntegrand_sigmaWithISR_down172()

const double StandardModel::getIntegrand_sigmaWithISR_down172 ( double  x) const
protected

Definition at line 8355 of file StandardModel/src/StandardModel.cpp.

8356{
8357 double s = 172. * 172.;
8359}

◆ getIntegrand_sigmaWithISR_down183()

const double StandardModel::getIntegrand_sigmaWithISR_down183 ( double  x) const
protected

Definition at line 8361 of file StandardModel/src/StandardModel.cpp.

8362{
8363 double s = 183. * 183.;
8365}

◆ getIntegrand_sigmaWithISR_down189()

const double StandardModel::getIntegrand_sigmaWithISR_down189 ( double  x) const
protected

Definition at line 8367 of file StandardModel/src/StandardModel.cpp.

8368{
8369 double s = 189. * 189.;
8371}

◆ getIntegrand_sigmaWithISR_down192()

const double StandardModel::getIntegrand_sigmaWithISR_down192 ( double  x) const
protected

Definition at line 8373 of file StandardModel/src/StandardModel.cpp.

8374{
8375 double s = 192. * 192.;
8377}

◆ getIntegrand_sigmaWithISR_down196()

const double StandardModel::getIntegrand_sigmaWithISR_down196 ( double  x) const
protected

Definition at line 8379 of file StandardModel/src/StandardModel.cpp.

8380{
8381 double s = 196. * 196.;
8383}

◆ getIntegrand_sigmaWithISR_down200()

const double StandardModel::getIntegrand_sigmaWithISR_down200 ( double  x) const
protected

Definition at line 8385 of file StandardModel/src/StandardModel.cpp.

8386{
8387 double s = 200. * 200.;
8389}

◆ getIntegrand_sigmaWithISR_down202()

const double StandardModel::getIntegrand_sigmaWithISR_down202 ( double  x) const
protected

Definition at line 8391 of file StandardModel/src/StandardModel.cpp.

8392{
8393 double s = 202. * 202.;
8395}

◆ getIntegrand_sigmaWithISR_down205()

const double StandardModel::getIntegrand_sigmaWithISR_down205 ( double  x) const
protected

Definition at line 8397 of file StandardModel/src/StandardModel.cpp.

8398{
8399 double s = 205. * 205.;
8401}

◆ getIntegrand_sigmaWithISR_down207()

const double StandardModel::getIntegrand_sigmaWithISR_down207 ( double  x) const
protected

Definition at line 8403 of file StandardModel/src/StandardModel.cpp.

8404{
8405 double s = 207. * 207.;
8407}

◆ getIntegrand_sigmaWithISR_mu130()

const double StandardModel::getIntegrand_sigmaWithISR_mu130 ( double  x) const
protected

Definition at line 8068 of file StandardModel/src/StandardModel.cpp.

8069{
8070 double s = 130. * 130.;
8072}
const double Integrand_sigmaWithISR_l(double x, const QCD::lepton l_flavor, const double s) const

◆ getIntegrand_sigmaWithISR_mu136()

const double StandardModel::getIntegrand_sigmaWithISR_mu136 ( double  x) const
protected

Definition at line 8074 of file StandardModel/src/StandardModel.cpp.

8075{
8076 double s = 136. * 136.;
8078}

◆ getIntegrand_sigmaWithISR_mu161()

const double StandardModel::getIntegrand_sigmaWithISR_mu161 ( double  x) const
protected

Definition at line 8080 of file StandardModel/src/StandardModel.cpp.

8081{
8082 double s = 161. * 161.;
8084}

◆ getIntegrand_sigmaWithISR_mu172()

const double StandardModel::getIntegrand_sigmaWithISR_mu172 ( double  x) const
protected

Definition at line 8086 of file StandardModel/src/StandardModel.cpp.

8087{
8088 double s = 172. * 172.;
8090}

◆ getIntegrand_sigmaWithISR_mu183()

const double StandardModel::getIntegrand_sigmaWithISR_mu183 ( double  x) const
protected

Definition at line 8092 of file StandardModel/src/StandardModel.cpp.

8093{
8094 double s = 183. * 183.;
8096}

◆ getIntegrand_sigmaWithISR_mu189()

const double StandardModel::getIntegrand_sigmaWithISR_mu189 ( double  x) const
protected

Definition at line 8098 of file StandardModel/src/StandardModel.cpp.

8099{
8100 double s = 189. * 189.;
8102}

◆ getIntegrand_sigmaWithISR_mu192()

const double StandardModel::getIntegrand_sigmaWithISR_mu192 ( double  x) const
protected

Definition at line 8104 of file StandardModel/src/StandardModel.cpp.

8105{
8106 double s = 192. * 192.;
8108}

◆ getIntegrand_sigmaWithISR_mu196()

const double StandardModel::getIntegrand_sigmaWithISR_mu196 ( double  x) const
protected

Definition at line 8110 of file StandardModel/src/StandardModel.cpp.

8111{
8112 double s = 196. * 196.;
8114}

◆ getIntegrand_sigmaWithISR_mu200()

const double StandardModel::getIntegrand_sigmaWithISR_mu200 ( double  x) const
protected

Definition at line 8116 of file StandardModel/src/StandardModel.cpp.

8117{
8118 double s = 200. * 200.;
8120}

◆ getIntegrand_sigmaWithISR_mu202()

const double StandardModel::getIntegrand_sigmaWithISR_mu202 ( double  x) const
protected

Definition at line 8122 of file StandardModel/src/StandardModel.cpp.

8123{
8124 double s = 202. * 202.;
8126}

◆ getIntegrand_sigmaWithISR_mu205()

const double StandardModel::getIntegrand_sigmaWithISR_mu205 ( double  x) const
protected

Definition at line 8128 of file StandardModel/src/StandardModel.cpp.

8129{
8130 double s = 205. * 205.;
8132}

◆ getIntegrand_sigmaWithISR_mu207()

const double StandardModel::getIntegrand_sigmaWithISR_mu207 ( double  x) const
protected

Definition at line 8134 of file StandardModel/src/StandardModel.cpp.

8135{
8136 double s = 207. * 207.;
8138}

◆ getIntegrand_sigmaWithISR_strange130()

const double StandardModel::getIntegrand_sigmaWithISR_strange130 ( double  x) const
protected

Definition at line 8501 of file StandardModel/src/StandardModel.cpp.

8502{
8503 double s = 130. * 130.;
8505}

◆ getIntegrand_sigmaWithISR_strange133()

const double StandardModel::getIntegrand_sigmaWithISR_strange133 ( double  x) const
protected

Definition at line 8507 of file StandardModel/src/StandardModel.cpp.

8508{
8509 double s = 133. * 133.;
8511}

◆ getIntegrand_sigmaWithISR_strange136()

const double StandardModel::getIntegrand_sigmaWithISR_strange136 ( double  x) const
protected

Definition at line 8513 of file StandardModel/src/StandardModel.cpp.

8514{
8515 double s = 136. * 136.;
8517}

◆ getIntegrand_sigmaWithISR_strange161()

const double StandardModel::getIntegrand_sigmaWithISR_strange161 ( double  x) const
protected

Definition at line 8519 of file StandardModel/src/StandardModel.cpp.

8520{
8521 double s = 161. * 161.;
8523}

◆ getIntegrand_sigmaWithISR_strange167()

const double StandardModel::getIntegrand_sigmaWithISR_strange167 ( double  x) const
protected

Definition at line 8525 of file StandardModel/src/StandardModel.cpp.

8526{
8527 double s = 167. * 167.;
8529}

◆ getIntegrand_sigmaWithISR_strange172()

const double StandardModel::getIntegrand_sigmaWithISR_strange172 ( double  x) const
protected

Definition at line 8531 of file StandardModel/src/StandardModel.cpp.

8532{
8533 double s = 172. * 172.;
8535}

◆ getIntegrand_sigmaWithISR_strange183()

const double StandardModel::getIntegrand_sigmaWithISR_strange183 ( double  x) const
protected

Definition at line 8537 of file StandardModel/src/StandardModel.cpp.

8538{
8539 double s = 183. * 183.;
8541}

◆ getIntegrand_sigmaWithISR_strange189()

const double StandardModel::getIntegrand_sigmaWithISR_strange189 ( double  x) const
protected

Definition at line 8543 of file StandardModel/src/StandardModel.cpp.

8544{
8545 double s = 189. * 189.;
8547}

◆ getIntegrand_sigmaWithISR_strange192()

const double StandardModel::getIntegrand_sigmaWithISR_strange192 ( double  x) const
protected

Definition at line 8549 of file StandardModel/src/StandardModel.cpp.

8550{
8551 double s = 192. * 192.;
8553}

◆ getIntegrand_sigmaWithISR_strange196()

const double StandardModel::getIntegrand_sigmaWithISR_strange196 ( double  x) const
protected

Definition at line 8555 of file StandardModel/src/StandardModel.cpp.

8556{
8557 double s = 196. * 196.;
8559}

◆ getIntegrand_sigmaWithISR_strange200()

const double StandardModel::getIntegrand_sigmaWithISR_strange200 ( double  x) const
protected

Definition at line 8561 of file StandardModel/src/StandardModel.cpp.

8562{
8563 double s = 200. * 200.;
8565}

◆ getIntegrand_sigmaWithISR_strange202()

const double StandardModel::getIntegrand_sigmaWithISR_strange202 ( double  x) const
protected

Definition at line 8567 of file StandardModel/src/StandardModel.cpp.

8568{
8569 double s = 202. * 202.;
8571}

◆ getIntegrand_sigmaWithISR_strange205()

const double StandardModel::getIntegrand_sigmaWithISR_strange205 ( double  x) const
protected

Definition at line 8573 of file StandardModel/src/StandardModel.cpp.

8574{
8575 double s = 205. * 205.;
8577}

◆ getIntegrand_sigmaWithISR_strange207()

const double StandardModel::getIntegrand_sigmaWithISR_strange207 ( double  x) const
protected

Definition at line 8579 of file StandardModel/src/StandardModel.cpp.

8580{
8581 double s = 207. * 207.;
8583}

◆ getIntegrand_sigmaWithISR_tau130()

const double StandardModel::getIntegrand_sigmaWithISR_tau130 ( double  x) const
protected

Definition at line 8141 of file StandardModel/src/StandardModel.cpp.

8142{
8143 double s = 130. * 130.;
8145}

◆ getIntegrand_sigmaWithISR_tau136()

const double StandardModel::getIntegrand_sigmaWithISR_tau136 ( double  x) const
protected

Definition at line 8147 of file StandardModel/src/StandardModel.cpp.

8148{
8149 double s = 136. * 136.;
8151}

◆ getIntegrand_sigmaWithISR_tau161()

const double StandardModel::getIntegrand_sigmaWithISR_tau161 ( double  x) const
protected

Definition at line 8153 of file StandardModel/src/StandardModel.cpp.

8154{
8155 double s = 161. * 161.;
8157}

◆ getIntegrand_sigmaWithISR_tau172()

const double StandardModel::getIntegrand_sigmaWithISR_tau172 ( double  x) const
protected

Definition at line 8159 of file StandardModel/src/StandardModel.cpp.

8160{
8161 double s = 172. * 172.;
8163}

◆ getIntegrand_sigmaWithISR_tau183()

const double StandardModel::getIntegrand_sigmaWithISR_tau183 ( double  x) const
protected

Definition at line 8165 of file StandardModel/src/StandardModel.cpp.

8166{
8167 double s = 183. * 183.;
8169}

◆ getIntegrand_sigmaWithISR_tau189()

const double StandardModel::getIntegrand_sigmaWithISR_tau189 ( double  x) const
protected

Definition at line 8171 of file StandardModel/src/StandardModel.cpp.

8172{
8173 double s = 189. * 189.;
8175}

◆ getIntegrand_sigmaWithISR_tau192()

const double StandardModel::getIntegrand_sigmaWithISR_tau192 ( double  x) const
protected

Definition at line 8177 of file StandardModel/src/StandardModel.cpp.

8178{
8179 double s = 192. * 192.;
8181}

◆ getIntegrand_sigmaWithISR_tau196()

const double StandardModel::getIntegrand_sigmaWithISR_tau196 ( double  x) const
protected

Definition at line 8183 of file StandardModel/src/StandardModel.cpp.

8184{
8185 double s = 196. * 196.;
8187}

◆ getIntegrand_sigmaWithISR_tau200()

const double StandardModel::getIntegrand_sigmaWithISR_tau200 ( double  x) const
protected

Definition at line 8189 of file StandardModel/src/StandardModel.cpp.

8190{
8191 double s = 200. * 200.;
8193}

◆ getIntegrand_sigmaWithISR_tau202()

const double StandardModel::getIntegrand_sigmaWithISR_tau202 ( double  x) const
protected

Definition at line 8195 of file StandardModel/src/StandardModel.cpp.

8196{
8197 double s = 202. * 202.;
8199}

◆ getIntegrand_sigmaWithISR_tau205()

const double StandardModel::getIntegrand_sigmaWithISR_tau205 ( double  x) const
protected

Definition at line 8201 of file StandardModel/src/StandardModel.cpp.

8202{
8203 double s = 205. * 205.;
8205}

◆ getIntegrand_sigmaWithISR_tau207()

const double StandardModel::getIntegrand_sigmaWithISR_tau207 ( double  x) const
protected

Definition at line 8207 of file StandardModel/src/StandardModel.cpp.

8208{
8209 double s = 207. * 207.;
8211}

◆ getIntegrand_sigmaWithISR_up130()

const double StandardModel::getIntegrand_sigmaWithISR_up130 ( double  x) const
protected

Definition at line 8237 of file StandardModel/src/StandardModel.cpp.

8238{
8239 double s = 130. * 130.;
8240 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8241}

◆ getIntegrand_sigmaWithISR_up133()

const double StandardModel::getIntegrand_sigmaWithISR_up133 ( double  x) const
protected

Definition at line 8243 of file StandardModel/src/StandardModel.cpp.

8244{
8245 double s = 133. * 133.;
8246 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8247}

◆ getIntegrand_sigmaWithISR_up136()

const double StandardModel::getIntegrand_sigmaWithISR_up136 ( double  x) const
protected

Definition at line 8249 of file StandardModel/src/StandardModel.cpp.

8250{
8251 double s = 136. * 136.;
8252 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8253}

◆ getIntegrand_sigmaWithISR_up161()

const double StandardModel::getIntegrand_sigmaWithISR_up161 ( double  x) const
protected

Definition at line 8255 of file StandardModel/src/StandardModel.cpp.

8256{
8257 double s = 161. * 161.;
8258 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8259}

◆ getIntegrand_sigmaWithISR_up167()

const double StandardModel::getIntegrand_sigmaWithISR_up167 ( double  x) const
protected

Definition at line 8261 of file StandardModel/src/StandardModel.cpp.

8262{
8263 double s = 167. * 167.;
8264 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8265}

◆ getIntegrand_sigmaWithISR_up172()

const double StandardModel::getIntegrand_sigmaWithISR_up172 ( double  x) const
protected

Definition at line 8267 of file StandardModel/src/StandardModel.cpp.

8268{
8269 double s = 172. * 172.;
8270 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8271}

◆ getIntegrand_sigmaWithISR_up183()

const double StandardModel::getIntegrand_sigmaWithISR_up183 ( double  x) const
protected

Definition at line 8273 of file StandardModel/src/StandardModel.cpp.

8274{
8275 double s = 183. * 183.;
8276 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8277}

◆ getIntegrand_sigmaWithISR_up189()

const double StandardModel::getIntegrand_sigmaWithISR_up189 ( double  x) const
protected

Definition at line 8279 of file StandardModel/src/StandardModel.cpp.

8280{
8281 double s = 189. * 189.;
8282 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8283}

◆ getIntegrand_sigmaWithISR_up192()

const double StandardModel::getIntegrand_sigmaWithISR_up192 ( double  x) const
protected

Definition at line 8285 of file StandardModel/src/StandardModel.cpp.

8286{
8287 double s = 192. * 192.;
8288 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8289}

◆ getIntegrand_sigmaWithISR_up196()

const double StandardModel::getIntegrand_sigmaWithISR_up196 ( double  x) const
protected

Definition at line 8291 of file StandardModel/src/StandardModel.cpp.

8292{
8293 double s = 196. * 196.;
8294 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8295}

◆ getIntegrand_sigmaWithISR_up200()

const double StandardModel::getIntegrand_sigmaWithISR_up200 ( double  x) const
protected

Definition at line 8297 of file StandardModel/src/StandardModel.cpp.

8298{
8299 double s = 200. * 200.;
8300 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8301}

◆ getIntegrand_sigmaWithISR_up202()

const double StandardModel::getIntegrand_sigmaWithISR_up202 ( double  x) const
protected

Definition at line 8303 of file StandardModel/src/StandardModel.cpp.

8304{
8305 double s = 202. * 202.;
8306 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8307}

◆ getIntegrand_sigmaWithISR_up205()

const double StandardModel::getIntegrand_sigmaWithISR_up205 ( double  x) const
protected

Definition at line 8309 of file StandardModel/src/StandardModel.cpp.

8310{
8311 double s = 205. * 205.;
8312 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8313}

◆ getIntegrand_sigmaWithISR_up207()

const double StandardModel::getIntegrand_sigmaWithISR_up207 ( double  x) const
protected

Definition at line 8315 of file StandardModel/src/StandardModel.cpp.

8316{
8317 double s = 207. * 207.;
8318 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8319}

◆ getIterationNo()

const int StandardModel::getIterationNo ( ) const
inline

Definition at line 629 of file StandardModel.h.

630 {
631 return iterationNo;
632 }

◆ getLeptons()

const Particle & StandardModel::getLeptons ( const QCD::lepton  p) const
inline

A get method to retrieve the member object of a lepton.

Parameters
[in]pname of a lepton
Returns
an object of the lepton specified by name

Definition at line 756 of file StandardModel.h.

757 {
758 return leptons[p];
759 }

◆ getMatching()

virtual StandardModelMatching & StandardModel::getMatching ( ) const
inlinevirtual

A get method to access the member reference of type StandardModelMatching.

Returns
a reference to a StandardModelMatching object

Reimplemented in CMFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, RealWeakEFTLFV, GeorgiMachacek, LeftRightSymmetricModel, NPSMEFTd6, NPSMEFTd6General, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 997 of file StandardModel.h.

998 {
999 return SMM.getObj();
1000 }

◆ getMHl()

virtual const double StandardModel::getMHl ( ) const
inlinevirtual

A get method to retrieve the Higgs mass \(m_h\).

Returns
\(m_h\) in GeV

Reimplemented in SUSY.

Definition at line 821 of file StandardModel.h.

822 {
823 return mHl;
824 }

◆ getmq()

virtual const double StandardModel::getmq ( const QCD::quark  q,
const double  mu 
) const
inlinevirtual

The MSbar running quark mass computed at NLO.

Parameters
qthe quark flavour
muthe scale at which the running mass is returned
Returns
\( m_q^\overline{\mathrm{MS}}(\mu)\)

Definition at line 3342 of file StandardModel.h.

3343{
3344 return m_q(q, mu, FULLNLO);
3345}

◆ getMuw()

const double StandardModel::getMuw ( ) const
inline

A get method to retrieve the matching scale \(\mu_W\) around the weak scale.

Returns
\(\mu_W\) in GeV

Definition at line 983 of file StandardModel.h.

984 {
985 return muw;
986 }

◆ getMw()

const double StandardModel::getMw ( ) const
inline

A get method to access the input value of the mass of the \(W\) boson \(M_W\).

Returns
the \(W\)-boson mass \(M_W\)

Definition at line 774 of file StandardModel.h.

775 {
776 return Mw_inp;
777 }

◆ getMyApproximateFormulae()

EWSMApproximateFormulae * StandardModel::getMyApproximateFormulae ( ) const
inline

A get method to retrieve the member pointer of type EWSMApproximateFormulae.

Returns
the pointer myApproximateFormulae

Definition at line 1024 of file StandardModel.h.

1025 {
1026 return myApproximateFormulae;
1027 }

◆ getMyEWSMcache()

EWSMcache * StandardModel::getMyEWSMcache ( ) const
inline

A get method to retrieve the member pointer of type EWSMcache.

Returns
the pointer myEWSMcache

Definition at line 1006 of file StandardModel.h.

1007 {
1008 return myEWSMcache;
1009 }

◆ getMyLeptonFlavour()

LeptonFlavour * StandardModel::getMyLeptonFlavour ( ) const
inline

Definition at line 1070 of file StandardModel.h.

1071 {
1072 return myLeptonFlavour;
1073 }

◆ getMyOneLoopEW()

EWSMOneLoopEW * StandardModel::getMyOneLoopEW ( ) const
inline

A get method to retrieve the member pointer of type EWSMOneLoopEW,.

Returns
the pointer myOneLoopEW

Definition at line 1015 of file StandardModel.h.

1016 {
1017 return myOneLoopEW;
1018 }

◆ getMyThreeLoopEW()

EWSMThreeLoopEW * StandardModel::getMyThreeLoopEW ( ) const
inline

Definition at line 1040 of file StandardModel.h.

1041 {
1042 return myThreeLoopEW;
1043 }

◆ getMyThreeLoopEW2QCD()

EWSMThreeLoopEW2QCD * StandardModel::getMyThreeLoopEW2QCD ( ) const
inline

Definition at line 1045 of file StandardModel.h.

1046 {
1047 return myThreeLoopEW2QCD;
1048 }

◆ getMyThreeLoopQCD()

EWSMThreeLoopQCD * StandardModel::getMyThreeLoopQCD ( ) const
inline

Definition at line 1050 of file StandardModel.h.

1051 {
1052 return myThreeLoopQCD;
1053 }

◆ getMyTwoFermionsLEP2()

EWSMTwoFermionsLEP2 * StandardModel::getMyTwoFermionsLEP2 ( ) const
inline

A get method to retrieve the member pointer of type EWSMTwoFermionsLEP2.

Returns
the pointer myTwoFermionsLEP2

Definition at line 1034 of file StandardModel.h.

1035 {
1036 return myTwoFermionsLEP2;
1037 }

◆ getMyTwoLoopEW()

EWSMTwoLoopEW * StandardModel::getMyTwoLoopEW ( ) const
inline

Definition at line 1055 of file StandardModel.h.

1056 {
1057 return myTwoLoopEW;
1058 }

◆ getMyTwoLoopQCD()

EWSMTwoLoopQCD * StandardModel::getMyTwoLoopQCD ( ) const
inline

Definition at line 1060 of file StandardModel.h.

1061 {
1062 return myTwoLoopQCD;
1063 }

◆ getMz()

const double StandardModel::getMz ( ) const
inline

A get method to access the mass of the \(Z\) boson \(M_Z\).

Returns
the \(Z\)-boson mass \(M_Z\)

Definition at line 765 of file StandardModel.h.

766 {
767 return Mz;
768 }

◆ getPhiBd()

virtual const double StandardModel::getPhiBd ( ) const
inlinevirtual

Half the relative phase of the $B_d$ mixing amplitude w.r.t. the Standard Model one.

Returns
\(1/2 (\mathrm{arg}((M_{12}^{bd})_\mathrm{full})-\mathrm{arg}((M_{12}^{bd})_\mathrm{SM}))\vert\)

Reimplemented in NPDF2.

Definition at line 3143 of file StandardModel.h.

3144 {
3145 return 0.;
3146 }

◆ getPhiBs()

virtual const double StandardModel::getPhiBs ( ) const
inlinevirtual

Half the relative phase of the $B_s$ mixing amplitude w.r.t. the Standard Model one.

Returns
\( 1/2 (\mathrm{arg}((M_{12}^{bs})_\mathrm{full})-\mathrm{arg}((M_{12}^{bs})_\mathrm{SM}))\vert\)

Reimplemented in NPDF2.

Definition at line 3134 of file StandardModel.h.

3135 {
3136 return 0.;
3137 }

◆ getTrueSM()

virtual const StandardModel & StandardModel::getTrueSM ( ) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 988 of file StandardModel.h.

989 {
990 throw std::runtime_error("StandardModel::getTrueSM() must be overridden by the NP extension.");
991 }

◆ getUPMNS()

const gslpp::matrix< gslpp::complex > StandardModel::getUPMNS ( ) const
inline

A get method to retrieve the object of the PMNS matrix.

Returns
the PMNS matrix

Definition at line 963 of file StandardModel.h.

964 {
965 return myPMNS.getPMNS();
966 }

◆ getVCKM()

const gslpp::matrix< gslpp::complex > StandardModel::getVCKM ( ) const
inline

A get method to retrieve the CKM matrix.

Returns
the CKM matrix

Definition at line 943 of file StandardModel.h.

944 {
945 return myCKM.getCKM();
946 }

◆ getYd()

const gslpp::matrix< gslpp::complex > & StandardModel::getYd ( ) const
inline

A get method to retrieve the Yukawa matrix of the down-type quarks, \(Y_d\).

Returns
\(Y_d\)

Definition at line 3390 of file StandardModel.h.

3391 {
3392 return Yd;
3393 }

◆ getYe()

const gslpp::matrix< gslpp::complex > & StandardModel::getYe ( ) const
inline

A get method to retrieve the Yukawa matrix of the charged leptons, \(Y_e\).

Returns
\(Y_e\)

Definition at line 3410 of file StandardModel.h.

3411 {
3412 return Ye;
3413 }

◆ getYn()

const gslpp::matrix< gslpp::complex > & StandardModel::getYn ( ) const
inline

A get method to retrieve the Yukawa matrix of the neutrinos, \(Y_\nu\).

Returns
\(Y_\nu\)

Definition at line 973 of file StandardModel.h.

974 {
975 return Yn;
976 }

◆ getYu()

const gslpp::matrix< gslpp::complex > & StandardModel::getYu ( ) const
inline

A get method to retrieve the Yukawa matrix of the up-type quarks, \(Y_u\).

Returns
\(Y_u\)

Definition at line 3370 of file StandardModel.h.

3371 {
3372 return Yu;
3373 }

◆ gLnuN2()

const double StandardModel::gLnuN2 ( ) const
virtual

The effective neutrino nucleon LH coupling: gLnuN2.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_L^2(\nu N)\)

Reimplemented in NPbase.

Definition at line 3007 of file StandardModel/src/StandardModel.cpp.

3008{
3009 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3011
3012 /* SM contribution with the approximate formula */
3014
3015 } else {
3016 throw std::runtime_error("ERROR: StandardModel::gLnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3017 }
3018}
double LEgLnuN2Approx() const
The effective neutrino nucleon LH coupling: gLnuN2.

◆ gRnuN2()

const double StandardModel::gRnuN2 ( ) const
virtual

The effective neutrino nucleon RH coupling: gRnuN2.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_R^2(\nu N)\)

Reimplemented in NPbase.

Definition at line 3021 of file StandardModel/src/StandardModel.cpp.

3022{
3023 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3025
3026 /* SM contribution with the approximate formula */
3028
3029 } else {
3030 throw std::runtime_error("ERROR: StandardModel::gRnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3031 }
3032}
double LEgRnuN2Approx() const
The effective neutrino nucleon RH coupling: gRnuN2.

◆ gV_f()

const gslpp::complex StandardModel::gV_f ( const Particle  f) const
virtual

The effective leptonic neutral-current vector coupling \(g_V^l\) in the SM.

\[ g_V^l = g_A^l (1 - 4|Q_l|\kappa_Z^l s_W^2)\,. \]

Parameters
[in]fa lepton or quark
Returns
\(g_{V,\,\mathrm{SM}}^l\)

Reimplemented in NPbase, and NPEpsilons.

Definition at line 1583 of file StandardModel/src/StandardModel.cpp.

1584{
1585 return ( gA_f(f)
1586 *(1.0 - 4.0 * fabs(f.getCharge())*(kappaZ_f(f)) * sW2()));
1587}

◆ gVnue()

const double StandardModel::gVnue ( ) const
virtual

The effective (muon) neutrino-electron vector coupling: gVnue.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_V^{\nu_\mu e}\)

Reimplemented in NPbase.

Definition at line 3061 of file StandardModel/src/StandardModel.cpp.

3062{
3063 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3065
3066 /* SM contribution with the approximate formula */
3068
3069 } else {
3070 throw std::runtime_error("ERROR: StandardModel::gVnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3071 }
3072}
double LEgVnueApprox() const
The effective (muon) neutrino-electron vector coupling: gVnue.

◆ I_triangle_1()

gslpp::complex StandardModel::I_triangle_1 ( const double  tau,
const double  lambda 
) const

Loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4737, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the particle in the loop.

Returns
\(I_1(\tau,\lambda)\)

Definition at line 3284 of file StandardModel/src/StandardModel.cpp.

3284 {
3285 gslpp::complex tmp;
3286
3287 tmp = (tau * lambda * (f_triangle(tau) - f_triangle(lambda)) + 2.0 * tau * (g_triangle(tau) - g_triangle(lambda))) / (tau - lambda);
3288
3289 tmp = tau * lambda * (1.0 + tmp) / (2.0 * (tau - lambda));
3290
3291 return tmp;
3292}
gslpp::complex g_triangle(const double tau) const
Loop function entering in the calculation of the effective coupling.

◆ I_triangle_2()

gslpp::complex StandardModel::I_triangle_2 ( const double  tau,
const double  lambda 
) const

Loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4737, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the particle in the loop.

Returns
\(I_2(\tau,\lambda)\)

Definition at line 3294 of file StandardModel/src/StandardModel.cpp.

3294 {
3295 gslpp::complex tmp;
3296
3297 tmp = -0.5 * tau * lambda * (f_triangle(tau) - f_triangle(lambda)) / (tau - lambda);
3298
3299 return tmp;
3300}

◆ Init()

bool StandardModel::Init ( const std::map< std::string, double > &  DPars)
virtual

A method to initialize the model parameters.

Parameters
[in]DParsa map of the parameters that are being updated in the Monte Carlo run (including parameters that are varied and those that are held constant)
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPSMEFTd6General, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 198 of file StandardModel/src/StandardModel.cpp.

199{
200 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
201 if (it->first.compare("AlsM") == 0 || it->first.compare("MAls") == 0)
202 throw std::runtime_error("ERROR: inappropriate parameter " + it->first
203 + " in model initialization");
204 else if (FlagFixMuwMut && it->first.compare("mut") == 0)
205 throw std::runtime_error("ERROR: cannot use " + it->first
206 + " when FlagFixMuwMut is true: use only muw");
207
208 std::map<std::string, double> myDPars(DPars);
209 myDPars["AlsM"] = myDPars.at("AlsMz"); // do not change!
210 myDPars["MAls"] = myDPars.at("Mz");
211 if (FlagFixMuwMut)
212 myDPars["mut"] = myDPars.at("muw") * 163. / 80.4 ;
213 return (QCD::Init(myDPars));
214}
virtual bool Init(const std::map< std::string, double > &DPars)
Initializes the QCD parameters found in the argument.
Definition: QCD.cpp:120

◆ InitializeModel()

bool StandardModel::InitializeModel ( )
virtual

A method to initialize the model.

This method, called via InputParser::ReadParameters(), allocates memory to the pointers defined in the current class.

Returns
a boolean that is true if model initialization is successful

< A pointer to an object of type EWSMcache.

< A pointer to an object of type EWSMOneLoopEW.

< A pointer to an object of type EWSMTwoLoopQCD.

< A pointer to an object of type EWSMThreeLoopQCD.

< A pointer to an object of type EWSMTwoLoopEW.

< A pointer to an object of type EWSMThreeLoopEW2QCD.

< A pointer to an object of type EWSMThreeLoopEW.

< A pointer to an object of type EWSMApproximateFormulae.

< A pointer to an object of type EWSMTwoFermionsLEP2.

Reimplemented in FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 176 of file StandardModel/src/StandardModel.cpp.

177{
178 myEWSMcache = new EWSMcache(*this);
186 myLeptonFlavour = new LeptonFlavour(*this);
187 /* BEGIN: REMOVE FROM THE PACKAGE */
189 /* END: REMOVE FROM THE PACKAGE */
191 return (true);
192}
A class for approximate formulae of the EW precision observables.
A class for one-loop corrections to the EW precision observables.
A class for three-loop corrections to the EW precision observables.
A class for three-loop corrections to the EW precision observables.
A class for three-loop corrections to the EW precision observables.
A class for the form factors , and in the processes at LEP-II.
A class for two-loop corrections to the EW precision observables.
Definition: EWSMTwoLoopEW.h:57
A class for two-loop corrections to the EW precision observables.
A class for cache variables used in computing radiative corrections to the EW precision observables.
Definition: EWSMcache.h:40
The parent class in LeptonFlavour for calculating all the Wilson coefficients for various Lepton Flav...
Definition: LeptonFlavour.h:26
void setModelInitialized(bool ModelInitialized)
A set method to fix the failure or success of the initialization of the model.
Definition: Model.h:145

◆ Integrand_AFBnumeratorWithISR_l()

const double StandardModel::Integrand_AFBnumeratorWithISR_l ( double  x,
const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 9297 of file StandardModel/src/StandardModel.cpp.

9298{
9299 double sprime = (1.0 - x)*s;
9300 double Ncf = 1.0;
9301 double ml = getLeptons(l_flavor).getMass();
9302 double G3prime = myTwoFermionsLEP2->G_3prime_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9303 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9304
9305 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9306}
double G_3prime_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double H_ISR_FB(const double x, const double s) const

◆ Integrand_AFBnumeratorWithISR_q()

const double StandardModel::Integrand_AFBnumeratorWithISR_q ( double  x,
const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 9456 of file StandardModel/src/StandardModel.cpp.

9457{
9458 double sprime = (1.0 - x)*s;
9459 double Ncf = 3.0;
9460 double mq = m_q(q_flavor, sqrt(s));
9461 double G3prime = myTwoFermionsLEP2->G_3prime_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9462 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9463
9464 if (flagLEP2[QCDFSR])
9465 G3prime *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, sprime);
9466
9467 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9468}
double G_3prime_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const

◆ Integrand_dsigmaBox_l()

const double StandardModel::Integrand_dsigmaBox_l ( double  cosTheta,
const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8677 of file StandardModel/src/StandardModel.cpp.

8678{
8679 double ml = getLeptons(l_flavor).getMass();
8680 return ( myTwoFermionsLEP2->dsigma_l_box(l_flavor, ml, s, cosTheta, Mw(), Gamma_Z()) );
8681}
double dsigma_l_box(const QCD::lepton l, const double mf, const double s, const double cosTheta, const double Mw, const double GammaZ) const
An observable class for the -boson mass.
Definition: Mw.h:22

◆ Integrand_dsigmaBox_q()

const double StandardModel::Integrand_dsigmaBox_q ( double  cosTheta,
const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8836 of file StandardModel/src/StandardModel.cpp.

8837{
8838 double mq = m_q(q_flavor, sqrt(s));
8839 return ( myTwoFermionsLEP2->dsigma_q_box(q_flavor, mq, s, cosTheta, Mw(), Gamma_Z()) );
8840}
double dsigma_q_box(const QCD::quark q, const double mf, const double s, const double cosTheta, const double Mw, const double GammaZ) const

◆ Integrand_sigmaWithISR_l()

const double StandardModel::Integrand_sigmaWithISR_l ( double  x,
const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8053 of file StandardModel/src/StandardModel.cpp.

8054{
8055 double sprime = (1.0 - x)*s;
8056 double ml = getLeptons(l_flavor).getMass();
8057 double l_charge = getLeptons(l_flavor).getCharge();
8058 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),
8059 flagLEP2[Weak]);
8060 double H = myTwoFermionsLEP2->H_ISR(x, s);
8061
8062 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8063 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, l_charge);
8064
8065 return ( H*sigma );
8066}
double QED_FSR_forSigma(const double s, const double Qf) const
double sigma_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double H_ISR(const double x, const double s) const

◆ Integrand_sigmaWithISR_q()

const double StandardModel::Integrand_sigmaWithISR_q ( double  x,
const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8213 of file StandardModel/src/StandardModel.cpp.

8214{
8215 double sprime = (1.0 - x)*s;
8216 double mq = m_q(q_flavor, sqrt(s));
8217 double q_charge = getQuarks(q_flavor).getCharge();
8218 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),
8219 flagLEP2[Weak]);
8220 double H = myTwoFermionsLEP2->H_ISR(x, s);
8221
8222 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8223 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, q_charge);
8224
8225 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8226 sigma *= myTwoFermionsLEP2->QCD_FSR_forSigma(sprime);
8227
8228 return ( H*sigma );
8229}
double sigma_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double QCD_FSR_forSigma(const double s) const
const Particle & getQuarks(const QCD::quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:536

◆ intMLL2eeeeus2()

const double StandardModel::intMLL2eeeeus2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3973 of file StandardModel/src/StandardModel.cpp.

3973 {
3974
3975 double intM2;
3976 double sw2cw2;
3977 double gLeSM;
3978 double GammaZSM;
3979 double Mz2, Mz4, s2;
3980
3981 sw2cw2 = s02() * c02();
3982 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3983 GammaZSM = Gamma_Z();
3984 Mz2 = Mz * Mz;
3985 Mz4 = Mz2 * Mz2;
3986 s2 = s * s;
3987
3988 intM2 = (gLeSM*gLeSM*gLeSM*gLeSM*s2 + 2.0*gLeSM*gLeSM*s*(-Mz2 + s)*sw2cw2 + sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))/(3.0*s2*sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))*(pow(s + t1,3.0) - pow(s + t0,3.0)) +
3989 ((2.0*(1.0 + (gLeSM*gLeSM*s*(-Mz2 + s))/(sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))) )/s)*(2.0*s *(t1 - t0) + (t1*t1 - t0*t0)/2.0 + s2*log(t1/t0)) +
3990 (2.0*gLeSM*gLeSM* (-sw2cw2 + (gLeSM*gLeSM*(Mz2 - s)*s)/(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM))))/(s*sw2cw2*sw2cw2)* (-(1.0/2.0)*t1*(2.0*Mz2 + 4.0*s + t1) + (1.0/2.0)*t0*(2.0*Mz2 + 4.0*s + t0) - (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)) ) +
3991 (2.0*(gLeSM*gLeSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
3992 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
3993 (gLeSM*gLeSM*gLeSM*gLeSM /sw2cw2/sw2cw2)*((Mz2 + s)*(Mz2 + s)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) + t1 - t0 + 2.0*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)));
3994
3995 return intM2;
3996}

◆ intMLR2eeeets2()

const double StandardModel::intMLR2eeeets2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3929 of file StandardModel/src/StandardModel.cpp.

3929 {
3930
3931 double intM2;
3932 double sw2cw2;
3933 double gLeSM,gReSM;
3934 double GammaZSM;
3935 double Mz2, s2;
3936 double propZSM2,propZSMRe,MeeLR2SM;
3937
3938 sw2cw2 = s02() * c02();
3939 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3940 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3941 GammaZSM = Gamma_Z();
3942 Mz2 = Mz * Mz;
3943 s2 = s * s;
3944
3945 propZSM2 = s2/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3946 propZSMRe = (s*(s - Mz2))/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3947
3948 MeeLR2SM = 1.0 + (gLeSM*gLeSM*gReSM*gReSM/(sw2cw2*sw2cw2))*propZSM2 + 2.0*(gLeSM*gReSM/sw2cw2)*propZSMRe;
3949
3950 intM2 = MeeLR2SM*(t1*t1*t1 - t0*t0*t0)/(3.0*s*s);
3951
3952 return intM2;
3953}

◆ intMLRtilde2eeeest2()

const double StandardModel::intMLRtilde2eeeest2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3955 of file StandardModel/src/StandardModel.cpp.

3955 {
3956
3957 double intM2;
3958 double sw2cw2;
3959 double gLeSM,gReSM;
3960 double Mz2;
3961
3962 sw2cw2 = s02() * c02();
3963 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3964 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3965 Mz2 = Mz * Mz;
3966
3967 intM2 = s*s*(((gLeSM*gLeSM*gReSM*gReSM)/sw2cw2/sw2cw2)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) - 1.0/t1 + 1.0/t0 +
3968 (2.0*gLeSM*gReSM*(-log(t1/t0) + log((-Mz2 + t1)/(-Mz2 + t0))))/(Mz2*sw2cw2));
3969
3970 return intM2;
3971}

◆ intMRR2eeeeus2()

const double StandardModel::intMRR2eeeeus2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3998 of file StandardModel/src/StandardModel.cpp.

3998 {
3999
4000 double intM2;
4001 double sw2cw2;
4002 double gReSM;
4003 double GammaZSM;
4004 double Mz2, Mz4, s2;
4005
4006 sw2cw2 = s02() * c02();
4007 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
4008 GammaZSM = Gamma_Z();
4009 Mz2 = Mz * Mz;
4010 Mz4 = Mz2 * Mz2;
4011 s2 = s * s;
4012
4013 intM2 = (gReSM*gReSM*gReSM*gReSM*s2 + 2.0*gReSM*gReSM*s*(-Mz2 + s)*sw2cw2 + sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))/(3.0*s2*sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))*(pow(s + t1,3.0) - pow(s + t0,3.0)) +
4014 ((2.0*(1.0 + (gReSM*gReSM*s*(-Mz2 + s))/(sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))) )/s)*(2.0*s *(t1 - t0) + (t1*t1 - t0*t0)/2.0 + s2*log(t1/t0)) +
4015 (2.0*gReSM*gReSM* (-sw2cw2 + (gReSM*gReSM*(Mz2 - s)*s)/(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM))))/(s*sw2cw2*sw2cw2)* (-(1.0/2.0)*t1*(2.0*Mz2 + 4.0*s + t1) + (1.0/2.0)*t0*(2.0*Mz2 + 4.0*s + t0) - (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)) ) +
4016 (2.0*(gReSM*gReSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
4017 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
4018 (gReSM*gReSM*gReSM*gReSM /sw2cw2/sw2cw2)*((Mz2 + s)*(Mz2 + s)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) + t1 - t0 + 2.0*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)));
4019
4020 return intM2;
4021}

◆ IsFlagNoApproximateGammaZ()

const bool StandardModel::IsFlagNoApproximateGammaZ ( ) const
inline

A method to retrieve the model flag NoApproximateGammaZ.

See StandardModelFlags for detail.

Returns
a boolean that is true if the two-loop approximate formulae of the partial and total decay widths of the \(Z\) boson defined with the function EWSMApproximateFormulae::X_full_2_loop() is NOT employed

Definition at line 691 of file StandardModel.h.

692 {
694 }

◆ IsFlagWithoutNonUniversalVC()

const bool StandardModel::IsFlagWithoutNonUniversalVC ( ) const
inline

A method to retrieve the model flag WithoutNonUniversalVC.

See StandardModelFlags for detail.

Returns
a boolean that is true if flavour non-universal vertex corrections are NOT added to the epsilon parameters describing new physics contribution
Attention
The flag FlagWithoutNonUniversalVC is applicable only for the models StandardModel and NPEpsilons.

Definition at line 678 of file StandardModel.h.

679 {
681 }

◆ isSMSuccess()

const bool StandardModel::isSMSuccess ( ) const
inline

A get method to retrieve the success status of the Standard Model update and matching.

Returns
a boolean that is true if the Standard Model update and matching were successful

Definition at line 3429 of file StandardModel.h.

3430 {
3431 return SMSuccess;
3432 }
bool SMSuccess
A boolean for the success of the Standard Model update and matching.

◆ kappaZ_f()

const gslpp::complex StandardModel::kappaZ_f ( const Particle  f) const
virtual

The effective leptonic neutral-current coupling \(\kappa_Z^l\) in the SM.

This function collects the radiative corrections to \(\kappa_Z^l\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes. The real part is computed with the function resumKappaZ(), while only the one-loop contribution is kept in the imaginary part.

As a part of the two-loop EW contribution, a correction associated with the product of the imaginary part of \(\Delta\alpha\) and that of \(\Pi_{Z\gamma}\) is included [Bardin:1999ak], [Bardin:1999yd] :

\begin{eqnarray} \Delta \kappa_Z^l = - \frac{1}{s_W^2}\left( \frac{\alpha(M_Z^2)}{4\pi} \right)^2 {\rm Im}\,\overline{\Pi}_{\gamma\gamma}^{\rm fer}(M_Z^2)\,\, {\rm Im}\,\overline{\Pi}_{Z\gamma}^{\rm fer}(M_Z^2) = \frac{35\alpha^2(M_Z^2)}{18 s_W^2}\, \left( 1 - \frac{8}{3}\, {\rm Re}(\kappa_Z^l) s_W^2 \right). \end{eqnarray}

Parameters
[in]fa lepton or quark
Returns
\(\kappa_{Z,\,\mathrm{SM}}^l\)
See also
resumKappaZ()
Attention
If the model flag CacheInStandardModel of StandardModel is set to true, the caching method implemented in the current class is employed.

Reimplemented in NPbase, and NPEpsilons.

Definition at line 1659 of file StandardModel/src/StandardModel.cpp.

1660{
1661 if (f.is("TOP")) return (gslpp::complex(0.0, 0.0, false));
1662
1664 if (useKappaZ_f_cache[f.getIndex()])
1665 return kappaZ_f_cache[f.getIndex()];
1666
1667 double myMw = Mw();
1668
1669 double ReKappaZf = 0.0, ImKappaZf = 0.0;
1670 if (FlagKappaZ.compare("APPROXIMATEFORMULA") == 0) {
1671
1672// Choose the correct formulae for the effective angle
1673 if ( f.is("BOTTOM") ){
1674 ReKappaZf = myApproximateFormulae->sin2thetaEff_b_full() / sW2();
1675 } else if ( f.is("ELECTRON") || f.is("MU") || f.is("TAU") ) {
1676 ReKappaZf = myApproximateFormulae->sin2thetaEff_l_full() / sW2();
1677 } else {
1678 ReKappaZf = myApproximateFormulae->sin2thetaEff(f) / sW2();
1679 }
1680
1681 ImKappaZf = myOneLoopEW->deltaKappa_rem_f(f, myMw).imag();
1682#ifdef WITHIMTWOLOOPQCD
1683 ImKappaZf += myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag();
1684
1685 /* TEST */
1686 //ImKappaZf -= myCache->ale()*myCache->alsMz()/24.0/M_PI*(cW2() - sW2())/sW2()/sW2();
1687#endif
1688 } else {
1689 /* compute Delta rho */
1690 double DeltaRho[orders_EW_size];
1691 ComputeDeltaRho(myMw, DeltaRho);
1692
1693 /* compute delta kappa_rem^f */
1694 gslpp::complex deltaKappa_remf[orders_EW_size];
1695 deltaKappa_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1696 deltaKappa_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1697 deltaKappa_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1698 deltaKappa_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1699 deltaKappa_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1700 deltaKappa_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1701 if (flag_order[EW1])
1702 deltaKappa_remf[EW1] = myOneLoopEW->deltaKappa_rem_f(f, myMw);
1703 if (flag_order[EW1QCD1])
1704#ifdef WITHIMTWOLOOPQCD
1705 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(),
1706 myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag(), false);
1707#else
1708 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1709#endif
1710 if (flag_order[EW1QCD2])
1711 deltaKappa_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1712 if (flag_order[EW2])
1713 deltaKappa_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1714 if (flag_order[EW2QCD1])
1715 deltaKappa_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1716 if (flag_order[EW3])
1717 deltaKappa_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1718
1719 /* compute Delta rbar_rem */
1720 double DeltaRbar_rem = 0.0;
1721 if (flag_order[EW1])
1722 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1723
1724 /* Re[kappa_Z^f] with or without resummation */
1725 double deltaKappa_rem_f_real[orders_EW_size];
1726 for (int j = 0; j < orders_EW_size; ++j)
1727 deltaKappa_rem_f_real[j] = deltaKappa_remf[j].real();
1728
1729 ReKappaZf = resumKappaZ(DeltaRho, deltaKappa_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1730
1731 /* O(alpha^2) correction to Re[kappa_Z^f] from the Z-gamma mixing */
1732 ReKappaZf += 35.0 * alphaMz() * alphaMz() / 18.0 / sW2()
1733 *(1.0 - 8.0 / 3.0 * ReKappaZf * sW2());
1734
1735 /* Im[kappa_Z^f] without resummation */
1736 for (int j = 0; j < orders_EW_size; ++j)
1737 ImKappaZf += deltaKappa_remf[j].imag();
1738 }
1739
1740 kappaZ_f_cache[f.getIndex()] = gslpp::complex(ReKappaZf, ImKappaZf, false);
1741 useKappaZ_f_cache[f.getIndex()] = true;
1742 return (gslpp::complex(ReKappaZf, ImKappaZf, false));
1743}
double sin2thetaEff(const Particle p) const
The value of the effective weak mixing anlge for a given fermion.
double sin2thetaEff_b_full() const
with the full two-loop EW corrections.
double sin2thetaEff_l_full() const
with the full two-loop EW corrections.
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
double DeltaRbar_rem(const double Mw_i) const
.
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
void ComputeDeltaRho(const double Mw_i, double DeltaRho[orders_EW_size]) const
A method to collect computed via subclasses.
double resumKappaZ(const double DeltaRho[orders_EW_size], const double deltaKappa_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
A method to compute the real part of the effetvive coupling from , and .

◆ LEP2AFBbottom()

const double StandardModel::LEP2AFBbottom ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 6163 of file StandardModel/src/StandardModel.cpp.

6164{
6165
6166 bSigmaForAFB = true;
6167 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6168 double relerr = 1.e-7;
6169 double abserr = 1.e-17;
6170
6171 if(s == 133.*133.){
6172 double AFB_noBox, sigma = 0.0;
6173 if (!flagLEP2[ISR])
6174 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6175 else {
6176 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133, &(*this), _1));
6177 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6178 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6179 }
6180 double numerator = average; // interval
6181
6182
6183 sigma = LEP2sigmaBottom(s);
6184
6185 AFB_noBox = numerator/sigma;
6186 }
6187 SMresult_cache = AFB_noBox;
6188
6189 if (flagLEP2[WeakBox]) {
6190 // numerator
6191 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6192 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6193 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6194 }
6195 double sigma_box_F = average; // interval
6196 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6197 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6198 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6199 }
6200 double sigma_box_B = average; // interval
6201
6202 // denominator
6203 if (!flagLEP2[ISR]) {
6204
6205 sigma = LEP2sigmaBottom(s);
6206 }
6207
6208 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6209 }
6210 } else if (s == 167.*167.){
6211 double AFB_noBox, sigma = 0.0;
6212 if (!flagLEP2[ISR])
6213 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6214 else {
6215 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167, &(*this), _1));
6216 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6217 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6218 }
6219 double numerator = average; // interval
6220
6221
6222 sigma = LEP2sigmaBottom(s);
6223
6224 AFB_noBox = numerator/sigma;
6225 }
6226 SMresult_cache = AFB_noBox;
6227
6228 if (flagLEP2[WeakBox]) {
6229 // numerator
6230 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6231 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6232 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6233 }
6234 double sigma_box_F = average; // interval
6235 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6236 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6237 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6238 }
6239 double sigma_box_B = average; // interval
6240
6241 // denominator
6242 if (!flagLEP2[ISR]) {
6243
6244 sigma = LEP2sigmaBottom(s);
6245 }
6246
6247 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6248 }
6249 } else if (s == 183.*183.) {
6250 double AFB_noBox, sigma = 0.0;
6251 if (!flagLEP2[ISR])
6252 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6253 else {
6254 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183, &(*this), _1));
6255 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6256 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6257 }
6258 double numerator = average; // interval
6259
6260
6261 sigma = LEP2sigmaBottom(s);
6262
6263 AFB_noBox = numerator/sigma;
6264 }
6265 SMresult_cache = AFB_noBox;
6266
6267 if (flagLEP2[WeakBox]) {
6268 // numerator
6269 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6270 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6271 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6272 }
6273 double sigma_box_F = average; // interval
6274 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6275 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6276 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6277 }
6278 double sigma_box_B = average; // interval
6279
6280 // denominator
6281 if (!flagLEP2[ISR]) {
6282
6283 sigma = LEP2sigmaBottom(s);
6284 }
6285
6286 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6287 }
6288 } else if (s == 189.*189.) {
6289 double AFB_noBox, sigma = 0.0;
6290 if (!flagLEP2[ISR])
6291 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6292 else {
6293 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189, &(*this), _1));
6294 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6295 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6296 }
6297 double numerator = average; // interval
6298
6299
6300 sigma = LEP2sigmaBottom(s);
6301
6302 AFB_noBox = numerator/sigma;
6303 }
6304 SMresult_cache = AFB_noBox;
6305
6306 if (flagLEP2[WeakBox]) {
6307 // numerator
6308 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6309 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6310 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6311 }
6312 double sigma_box_F = average; // interval
6313 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6314 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6315 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6316 }
6317 double sigma_box_B = average; // interval
6318
6319 // denominator
6320 if (!flagLEP2[ISR]) {
6321
6322 sigma = LEP2sigmaBottom(s);
6323 }
6324
6325 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6326 }
6327 } else if (s == 192.*192.) {
6328 double AFB_noBox, sigma = 0.0;
6329 if (!flagLEP2[ISR])
6330 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6331 else {
6332 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192, &(*this), _1));
6333 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6334 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6335 }
6336 double numerator = average; // interval
6337
6338
6339 sigma = LEP2sigmaBottom(s);
6340
6341 AFB_noBox = numerator/sigma;
6342 }
6343 SMresult_cache = AFB_noBox;
6344
6345 if (flagLEP2[WeakBox]) {
6346 // numerator
6347 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6348 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6349 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6350 }
6351 double sigma_box_F = average; // interval
6352 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6353 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6354 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6355 }
6356 double sigma_box_B = average; // interval
6357
6358 // denominator
6359 if (!flagLEP2[ISR]) {
6360
6361 sigma = LEP2sigmaBottom(s);
6362 }
6363
6364 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6365 }
6366 } else if (s == 196.*196.) {
6367 double AFB_noBox, sigma = 0.0;
6368 if (!flagLEP2[ISR])
6369 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6370 else {
6371 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196, &(*this), _1));
6372 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6373 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6374 }
6375 double numerator = average; // interval
6376
6377
6378 sigma = LEP2sigmaBottom(s);
6379
6380 AFB_noBox = numerator/sigma;
6381 }
6382 SMresult_cache = AFB_noBox;
6383
6384 if (flagLEP2[WeakBox]) {
6385 // numerator
6386 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6387 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6388 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6389 }
6390 double sigma_box_F = average; // interval
6391 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6392 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6393 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6394 }
6395 double sigma_box_B = average; // interval
6396
6397 // denominator
6398 if (!flagLEP2[ISR]) {
6399
6400 sigma = LEP2sigmaBottom(s);
6401 }
6402
6403 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6404 }
6405 } else if (s == 200.*200.) {
6406 double AFB_noBox, sigma = 0.0;
6407 if (!flagLEP2[ISR])
6408 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6409 else {
6410 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200, &(*this), _1));
6411 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6412 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6413 }
6414 double numerator = average; // interval
6415
6416
6417 sigma = LEP2sigmaBottom(s);
6418
6419 AFB_noBox = numerator/sigma;
6420 }
6421 SMresult_cache = AFB_noBox;
6422
6423 if (flagLEP2[WeakBox]) {
6424 // numerator
6425 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6426 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6427 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6428 }
6429 double sigma_box_F = average; // interval
6430 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6431 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6432 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6433 }
6434 double sigma_box_B = average; // interval
6435
6436 // denominator
6437 if (!flagLEP2[ISR]) {
6438
6439 sigma = LEP2sigmaBottom(s);
6440 }
6441
6442 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6443 }
6444 } else if (s == 202.*202.) {
6445 double AFB_noBox, sigma = 0.0;
6446 if (!flagLEP2[ISR])
6447 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6448 else {
6449 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202, &(*this), _1));
6450 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6451 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6452 }
6453 double numerator = average; // interval
6454
6455
6456 sigma = LEP2sigmaBottom(s);
6457
6458 AFB_noBox = numerator/sigma;
6459 }
6460 SMresult_cache = AFB_noBox;
6461
6462 if (flagLEP2[WeakBox]) {
6463 // numerator
6464 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6465 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6466 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6467 }
6468 double sigma_box_F = average; // interval
6469 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6470 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6471 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6472 }
6473 double sigma_box_B = average; // interval
6474
6475 // denominator
6476 if (!flagLEP2[ISR]) {
6477
6478 sigma = LEP2sigmaBottom(s);
6479 }
6480
6481 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6482 }
6483 } else if (s == 205.*205.) {
6484 double AFB_noBox, sigma = 0.0;
6485 if (!flagLEP2[ISR])
6486 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6487 else {
6488 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205, &(*this), _1));
6489 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6490 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6491 }
6492 double numerator = average; // interval
6493
6494
6495 sigma = LEP2sigmaBottom(s);
6496
6497 AFB_noBox = numerator/sigma;
6498 }
6499 SMresult_cache = AFB_noBox;
6500
6501 if (flagLEP2[WeakBox]) {
6502 // numerator
6503 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6504 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6505 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6506 }
6507 double sigma_box_F = average; // interval
6508 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6509 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6510 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6511 }
6512 double sigma_box_B = average; // interval
6513
6514 // denominator
6515 if (!flagLEP2[ISR]) {
6516
6517 sigma = LEP2sigmaBottom(s);
6518 }
6519
6520 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6521 }
6522 } else if (s == 207.*207.) {
6523 double AFB_noBox, sigma = 0.0;
6524 if (!flagLEP2[ISR])
6525 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6526 else {
6527 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207, &(*this), _1));
6528 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6529 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6530 }
6531 double numerator = average; // interval
6532
6533
6534 sigma = LEP2sigmaBottom(s);
6535
6536 AFB_noBox = numerator/sigma;
6537 }
6538 SMresult_cache = AFB_noBox;
6539
6540 if (flagLEP2[WeakBox]) {
6541 // numerator
6542 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6543 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6544 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6545 }
6546 double sigma_box_F = average; // interval
6547 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6548 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6549 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6550 }
6551 double sigma_box_B = average; // interval
6552
6553 // denominator
6554 if (!flagLEP2[ISR]) {
6555
6556 sigma = LEP2sigmaBottom(s);
6557 }
6558
6559 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6560 }
6561 } else {
6562 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBbottom!");
6563 }
6564
6565 double AFBbottom = SMresult_cache;
6566
6567 gsl_set_error_handler(old_handler);
6568 bSigmaForAFB = false;
6569 return AFBbottom;
6570
6571}
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBbottom.h:39
const double getIntegrand_AFBnumeratorWithISR_bottom192(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom196(double x) const
gsl_function f_GSL
const double getIntegrand_dsigmaBox_bottom189(double x) const
const double getIntegrand_dsigmaBox_bottom207(double x) const
double SMresult_cache
const double getIntegrand_dsigmaBox_bottom202(double x) const
const double getIntegrand_dsigmaBox_bottom200(double x) const
const double getIntegrand_dsigmaBox_bottom205(double x) const
const double getIntegrand_dsigmaBox_bottom183(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom207(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom200(double x) const
const double getIntegrand_dsigmaBox_bottom196(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom205(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom189(double x) const
const double AFB_NoISR_q(const QCD::quark q_flavor, const double s) const
const double getIntegrand_dsigmaBox_bottom133(double x) const
const double getIntegrand_dsigmaBox_bottom167(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom202(double x) const
const double getIntegrand_dsigmaBox_bottom192(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom167(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom133(double x) const
virtual const double LEP2sigmaBottom(const double s) const
const double getIntegrand_AFBnumeratorWithISR_bottom183(double x) const

◆ LEP2AFBcharm()

const double StandardModel::LEP2AFBcharm ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 6574 of file StandardModel/src/StandardModel.cpp.

6575{
6576
6577 bSigmaForAFB = true;
6578 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6579 double relerr = 1.e-7;
6580 double abserr = 1.e-17;
6581
6582 if(s == 133.*133.){
6583 double AFB_noBox, sigma = 0.0;
6584 if (!flagLEP2[ISR])
6585 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6586 else {
6587 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm133, &(*this), _1));
6588 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6589 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6590 }
6591 double numerator = average; // interval
6592
6593
6594 sigma = LEP2sigmaCharm(s);
6595
6596 AFB_noBox = numerator/sigma;
6597 }
6598 SMresult_cache = AFB_noBox;
6599
6600 if (flagLEP2[WeakBox]) {
6601 // numerator
6602 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6603 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6604 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6605 }
6606 double sigma_box_F = average; // interval
6607 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6608 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6609 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6610 }
6611 double sigma_box_B = average; // interval
6612
6613 // denominator
6614 if (!flagLEP2[ISR]) {
6615
6616 sigma = LEP2sigmaCharm(s);
6617 }
6618
6619 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6620 }
6621 } else if (s == 167.*167.){
6622 double AFB_noBox, sigma = 0.0;
6623 if (!flagLEP2[ISR])
6624 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6625 else {
6626 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm167, &(*this), _1));
6627 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6628 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6629 }
6630 double numerator = average; // interval
6631
6632
6633 sigma = LEP2sigmaCharm(s);
6634
6635 AFB_noBox = numerator/sigma;
6636 }
6637 SMresult_cache = AFB_noBox;
6638
6639 if (flagLEP2[WeakBox]) {
6640 // numerator
6641 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6642 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6643 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6644 }
6645 double sigma_box_F = average; // interval
6646 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6647 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6648 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6649 }
6650 double sigma_box_B = average; // interval
6651
6652 // denominator
6653 if (!flagLEP2[ISR]) {
6654
6655 sigma = LEP2sigmaCharm(s);
6656 }
6657
6658 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6659 }
6660 } else if (s == 183.*183.) {
6661 double AFB_noBox, sigma = 0.0;
6662 if (!flagLEP2[ISR])
6663 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6664 else {
6665 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm183, &(*this), _1));
6666 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6667 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6668 }
6669 double numerator = average; // interval
6670
6671
6672 sigma = LEP2sigmaCharm(s);
6673
6674 AFB_noBox = numerator/sigma;
6675 }
6676 SMresult_cache = AFB_noBox;
6677
6678 if (flagLEP2[WeakBox]) {
6679 // numerator
6680 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6681 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6682 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6683 }
6684 double sigma_box_F = average; // interval
6685 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6686 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6687 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6688 }
6689 double sigma_box_B = average; // interval
6690
6691 // denominator
6692 if (!flagLEP2[ISR]) {
6693
6694 sigma = LEP2sigmaCharm(s);
6695 }
6696
6697 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6698 }
6699 } else if (s == 189.*189.) {
6700 double AFB_noBox, sigma = 0.0;
6701 if (!flagLEP2[ISR])
6702 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6703 else {
6704 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm189, &(*this), _1));
6705 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6706 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6707 }
6708 double numerator = average; // interval
6709
6710
6711 sigma = LEP2sigmaCharm(s);
6712
6713 AFB_noBox = numerator/sigma;
6714 }
6715 SMresult_cache = AFB_noBox;
6716
6717 if (flagLEP2[WeakBox]) {
6718 // numerator
6719 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6720 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6721 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6722 }
6723 double sigma_box_F = average; // interval
6724 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6725 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6726 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6727 }
6728 double sigma_box_B = average; // interval
6729
6730 // denominator
6731 if (!flagLEP2[ISR]) {
6732
6733 sigma = LEP2sigmaCharm(s);
6734 }
6735
6736 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6737 }
6738 } else if (s == 192.*192.) {
6739 double AFB_noBox, sigma = 0.0;
6740 if (!flagLEP2[ISR])
6741 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6742 else {
6743 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm192, &(*this), _1));
6744 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6745 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6746 }
6747 double numerator = average; // interval
6748
6749
6750 sigma = LEP2sigmaCharm(s);
6751
6752 AFB_noBox = numerator/sigma;
6753 }
6754 SMresult_cache = AFB_noBox;
6755
6756 if (flagLEP2[WeakBox]) {
6757 // numerator
6758 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6759 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6760 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6761 }
6762 double sigma_box_F = average; // interval
6763 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6764 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6765 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6766 }
6767 double sigma_box_B = average; // interval
6768
6769 // denominator
6770 if (!flagLEP2[ISR]) {
6771
6772 sigma = LEP2sigmaCharm(s);
6773 }
6774
6775 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6776 }
6777 } else if (s == 196.*196.) {
6778 double AFB_noBox, sigma = 0.0;
6779 if (!flagLEP2[ISR])
6780 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6781 else {
6782 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm196, &(*this), _1));
6783 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6784 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6785 }
6786 double numerator = average; // interval
6787
6788
6789 sigma = LEP2sigmaCharm(s);
6790
6791 AFB_noBox = numerator/sigma;
6792 }
6793 SMresult_cache = AFB_noBox;
6794
6795 if (flagLEP2[WeakBox]) {
6796 // numerator
6797 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6798 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6799 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6800 }
6801 double sigma_box_F = average; // interval
6802 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6803 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6804 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6805 }
6806 double sigma_box_B = average; // interval
6807
6808 // denominator
6809 if (!flagLEP2[ISR]) {
6810
6811 sigma = LEP2sigmaCharm(s);
6812 }
6813
6814 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6815 }
6816 } else if (s == 200.*200.) {
6817 double AFB_noBox, sigma = 0.0;
6818 if (!flagLEP2[ISR])
6819 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6820 else {
6821 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm200, &(*this), _1));
6822 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6823 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6824 }
6825 double numerator = average; // interval
6826
6827
6828 sigma = LEP2sigmaCharm(s);
6829
6830 AFB_noBox = numerator/sigma;
6831 }
6832 SMresult_cache = AFB_noBox;
6833
6834 if (flagLEP2[WeakBox]) {
6835 // numerator
6836 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6837 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6838 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6839 }
6840 double sigma_box_F = average; // interval
6841 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6842 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6843 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6844 }
6845 double sigma_box_B = average; // interval
6846
6847 // denominator
6848 if (!flagLEP2[ISR]) {
6849
6850 sigma = LEP2sigmaCharm(s);
6851 }
6852
6853 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6854 }
6855 } else if (s == 202.*202.) {
6856 double AFB_noBox, sigma = 0.0;
6857 if (!flagLEP2[ISR])
6858 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6859 else {
6860 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm202, &(*this), _1));
6861 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6862 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6863 }
6864 double numerator = average; // interval
6865
6866
6867 sigma = LEP2sigmaCharm(s);
6868
6869 AFB_noBox = numerator/sigma;
6870 }
6871 SMresult_cache = AFB_noBox;
6872
6873 if (flagLEP2[WeakBox]) {
6874 // numerator
6875 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6876 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6877 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6878 }
6879 double sigma_box_F = average; // interval
6880 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6881 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6882 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6883 }
6884 double sigma_box_B = average; // interval
6885
6886 // denominator
6887 if (!flagLEP2[ISR]) {
6888
6889 sigma = LEP2sigmaCharm(s);
6890 }
6891
6892 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6893 }
6894 } else if (s == 205.*205.) {
6895 double AFB_noBox, sigma = 0.0;
6896 if (!flagLEP2[ISR])
6897 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6898 else {
6899 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6900 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6901 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6902 }
6903 double numerator = average; // interval
6904
6905
6906 sigma = LEP2sigmaCharm(s);
6907
6908 AFB_noBox = numerator/sigma;
6909 }
6910 SMresult_cache = AFB_noBox;
6911
6912 if (flagLEP2[WeakBox]) {
6913 // numerator
6914 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6915 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6916 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6917 }
6918 double sigma_box_F = average; // interval
6919 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6920 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6921 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6922 }
6923 double sigma_box_B = average; // interval
6924
6925 // denominator
6926 if (!flagLEP2[ISR]) {
6927
6928 sigma = LEP2sigmaCharm(s);
6929 }
6930
6931 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6932 }
6933 } else if (s == 207.*207.) {
6934 double AFB_noBox, sigma = 0.0;
6935 if (!flagLEP2[ISR])
6936 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6937 else {
6938 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6939 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6940 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6941 }
6942 double numerator = average; // interval
6943
6944
6945 sigma = LEP2sigmaCharm(s);
6946
6947 AFB_noBox = numerator/sigma;
6948 }
6949 SMresult_cache = AFB_noBox;
6950
6951 if (flagLEP2[WeakBox]) {
6952 // numerator
6953 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6954 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6955 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6956 }
6957 double sigma_box_F = average; // interval
6958 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6959 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6960 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6961 }
6962 double sigma_box_B = average; // interval
6963
6964 // denominator
6965 if (!flagLEP2[ISR]) {
6966
6967 sigma = LEP2sigmaCharm(s);
6968 }
6969
6970 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6971 }
6972 } else {
6973 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBcharm!");
6974 }
6975
6976 double AFBcharm = SMresult_cache;
6977
6978 gsl_set_error_handler(old_handler);
6979 bSigmaForAFB = false;
6980 return AFBcharm;
6981
6982}
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBcharm.h:32
virtual const double LEP2sigmaCharm(const double s) const
const double getIntegrand_AFBnumeratorWithISR_charm133(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm183(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm205(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm200(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm202(double x) const
const double getIntegrand_dsigmaBox_charm167(double x) const
const double getIntegrand_dsigmaBox_charm205(double x) const
const double getIntegrand_dsigmaBox_charm183(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm189(double x) const
const double getIntegrand_dsigmaBox_charm196(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm196(double x) const
const double getIntegrand_dsigmaBox_charm133(double x) const
const double getIntegrand_dsigmaBox_charm192(double x) const
const double getIntegrand_dsigmaBox_charm189(double x) const
const double getIntegrand_dsigmaBox_charm207(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm167(double x) const
const double getIntegrand_dsigmaBox_charm200(double x) const
const double getIntegrand_dsigmaBox_charm202(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm192(double x) const

◆ LEP2AFBe()

const double StandardModel::LEP2AFBe ( const double  s) const
virtual

Reimplemented in NPbase.

Definition at line 6984 of file StandardModel/src/StandardModel.cpp.

6985{
6986 return 0.;
6987}

◆ LEP2AFBmu()

const double StandardModel::LEP2AFBmu ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 6989 of file StandardModel/src/StandardModel.cpp.

6990{
6991
6992 bSigmaForAFB = true;
6993 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6994 double relerr = 1.e-7;
6995 double abserr = 1.e-17;
6996
6997 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
6999
7000 /* SM contribution with the approximate formula */
7002
7003 } else {
7004
7005 if(s == 130.*130.){
7006 double AFB_noBox, sigma = 0.0;
7007 if (!flagLEP2[ISR])
7008 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7009 else {
7010 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu130, &(*this), _1));
7011 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7012 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7013 }
7014 double numerator = average; // interval
7015
7016
7017 sigma = LEP2sigmaMu(s);
7018
7019 AFB_noBox = numerator/sigma;
7020 }
7021 SMresult_cache = AFB_noBox;
7022
7023 if (flagLEP2[WeakBox]) {
7024 // numerator
7025 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7026 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7027 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7028 }
7029 double sigma_box_F = average; // interval
7030 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7031 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7032 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7033 }
7034 double sigma_box_B = average; // interval
7035
7036 // denominator
7037 if (!flagLEP2[ISR]) {
7038
7039 sigma = LEP2sigmaMu(s);
7040 }
7041
7042 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7043 }
7044 } else if (s == 136.*136.){
7045 double AFB_noBox, sigma = 0.0;
7046 if (!flagLEP2[ISR])
7047 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7048 else {
7049 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu136, &(*this), _1));
7050 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7051 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7052 }
7053 double numerator = average; // interval
7054
7055
7056 sigma = LEP2sigmaMu(s);
7057
7058 AFB_noBox = numerator/sigma;
7059 }
7060 SMresult_cache = AFB_noBox;
7061
7062 if (flagLEP2[WeakBox]) {
7063 // numerator
7064 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7065 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7066 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7067 }
7068 double sigma_box_F = average; // interval
7069 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7070 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7071 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7072 }
7073 double sigma_box_B = average; // interval
7074
7075 // denominator
7076 if (!flagLEP2[ISR]) {
7077
7078 sigma = LEP2sigmaMu(s);
7079 }
7080
7081 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7082 }
7083 } else if (s == 161.*161.){
7084 double AFB_noBox, sigma = 0.0;
7085 if (!flagLEP2[ISR])
7086 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7087 else {
7088 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu161, &(*this), _1));
7089 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7090 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7091 }
7092 double numerator = average; // interval
7093
7094
7095 sigma = LEP2sigmaMu(s);
7096
7097 AFB_noBox = numerator/sigma;
7098 }
7099 SMresult_cache = AFB_noBox;
7100
7101 if (flagLEP2[WeakBox]) {
7102 // numerator
7103 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7104 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7105 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7106 }
7107 double sigma_box_F = average; // interval
7108 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7109 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7110 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7111 }
7112 double sigma_box_B = average; // interval
7113
7114 // denominator
7115 if (!flagLEP2[ISR]) {
7116
7117 sigma = LEP2sigmaMu(s);
7118 }
7119
7120 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7121 }
7122 } else if (s == 172.*172.){
7123 double AFB_noBox, sigma = 0.0;
7124 if (!flagLEP2[ISR])
7125 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7126 else {
7127 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu172, &(*this), _1));
7128 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7129 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7130 }
7131 double numerator = average; // interval
7132
7133
7134 sigma = LEP2sigmaMu(s);
7135
7136 AFB_noBox = numerator/sigma;
7137 }
7138 SMresult_cache = AFB_noBox;
7139
7140 if (flagLEP2[WeakBox]) {
7141 // numerator
7142 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7143 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7144 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7145 }
7146 double sigma_box_F = average; // interval
7147 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7148 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7149 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7150 }
7151 double sigma_box_B = average; // interval
7152
7153 // denominator
7154 if (!flagLEP2[ISR]) {
7155
7156 sigma = LEP2sigmaMu(s);
7157 }
7158
7159 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7160 }
7161 } else if (s == 183.*183.) {
7162 double AFB_noBox, sigma = 0.0;
7163 if (!flagLEP2[ISR])
7164 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7165 else {
7166 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu183, &(*this), _1));
7167 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7168 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7169 }
7170 double numerator = average; // interval
7171
7172
7173 sigma = LEP2sigmaMu(s);
7174
7175 AFB_noBox = numerator/sigma;
7176 }
7177 SMresult_cache = AFB_noBox;
7178
7179 if (flagLEP2[WeakBox]) {
7180 // numerator
7181 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7182 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7183 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7184 }
7185 double sigma_box_F = average; // interval
7186 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7187 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7188 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7189 }
7190 double sigma_box_B = average; // interval
7191
7192 // denominator
7193 if (!flagLEP2[ISR]) {
7194
7195 sigma = LEP2sigmaMu(s);
7196 }
7197
7198 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7199 }
7200 } else if (s == 189.*189.) {
7201 double AFB_noBox, sigma = 0.0;
7202 if (!flagLEP2[ISR])
7203 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7204 else {
7205 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu189, &(*this), _1));
7206 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7207 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7208 }
7209 double numerator = average; // interval
7210
7211
7212 sigma = LEP2sigmaMu(s);
7213
7214 AFB_noBox = numerator/sigma;
7215 }
7216 SMresult_cache = AFB_noBox;
7217
7218 if (flagLEP2[WeakBox]) {
7219 // numerator
7220 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7221 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7222 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7223 }
7224 double sigma_box_F = average; // interval
7225 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7226 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7227 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7228 }
7229 double sigma_box_B = average; // interval
7230
7231 // denominator
7232 if (!flagLEP2[ISR]) {
7233
7234 sigma = LEP2sigmaMu(s);
7235 }
7236
7237 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7238 }
7239 } else if (s == 192.*192.) {
7240 double AFB_noBox, sigma = 0.0;
7241 if (!flagLEP2[ISR])
7242 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7243 else {
7244 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu192, &(*this), _1));
7245 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7246 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7247 }
7248 double numerator = average; // interval
7249
7250
7251 sigma = LEP2sigmaMu(s);
7252
7253 AFB_noBox = numerator/sigma;
7254 }
7255 SMresult_cache = AFB_noBox;
7256
7257 if (flagLEP2[WeakBox]) {
7258 // numerator
7259 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7260 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7261 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7262 }
7263 double sigma_box_F = average; // interval
7264 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7265 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7266 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7267 }
7268 double sigma_box_B = average; // interval
7269
7270 // denominator
7271 if (!flagLEP2[ISR]) {
7272
7273 sigma = LEP2sigmaMu(s);
7274 }
7275
7276 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7277 }
7278 } else if (s == 196.*196.) {
7279 double AFB_noBox, sigma = 0.0;
7280 if (!flagLEP2[ISR])
7281 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7282 else {
7283 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu196, &(*this), _1));
7284 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7285 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7286 }
7287 double numerator = average; // interval
7288
7289
7290 sigma = LEP2sigmaMu(s);
7291
7292 AFB_noBox = numerator/sigma;
7293 }
7294 SMresult_cache = AFB_noBox;
7295
7296 if (flagLEP2[WeakBox]) {
7297 // numerator
7298 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7299 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7300 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7301 }
7302 double sigma_box_F = average; // interval
7303 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7304 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7305 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7306 }
7307 double sigma_box_B = average; // interval
7308
7309 // denominator
7310 if (!flagLEP2[ISR]) {
7311
7312 sigma = LEP2sigmaMu(s);
7313 }
7314
7315 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7316 }
7317 } else if (s == 200.*200.) {
7318 double AFB_noBox, sigma = 0.0;
7319 if (!flagLEP2[ISR])
7320 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7321 else {
7322 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu200, &(*this), _1));
7323 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7324 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7325 }
7326 double numerator = average; // interval
7327
7328
7329 sigma = LEP2sigmaMu(s);
7330
7331 AFB_noBox = numerator/sigma;
7332 }
7333 SMresult_cache = AFB_noBox;
7334
7335 if (flagLEP2[WeakBox]) {
7336 // numerator
7337 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7338 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7339 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7340 }
7341 double sigma_box_F = average; // interval
7342 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7343 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7344 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7345 }
7346 double sigma_box_B = average; // interval
7347
7348 // denominator
7349 if (!flagLEP2[ISR]) {
7350
7351 sigma = LEP2sigmaMu(s);
7352 }
7353
7354 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7355 }
7356 } else if (s == 202.*202.) {
7357 double AFB_noBox, sigma = 0.0;
7358 if (!flagLEP2[ISR])
7359 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7360 else {
7361 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu202, &(*this), _1));
7362 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7363 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7364 }
7365 double numerator = average; // interval
7366
7367
7368 sigma = LEP2sigmaMu(s);
7369
7370 AFB_noBox = numerator/sigma;
7371 }
7372 SMresult_cache = AFB_noBox;
7373
7374 if (flagLEP2[WeakBox]) {
7375 // numerator
7376 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7377 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7378 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7379 }
7380 double sigma_box_F = average; // interval
7381 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7382 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7383 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7384 }
7385 double sigma_box_B = average; // interval
7386
7387 // denominator
7388 if (!flagLEP2[ISR]) {
7389
7390 sigma = LEP2sigmaMu(s);
7391 }
7392
7393 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7394 }
7395 } else if (s == 205.*205.) {
7396 double AFB_noBox, sigma = 0.0;
7397 if (!flagLEP2[ISR])
7398 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7399 else {
7400 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu205, &(*this), _1));
7401 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7402 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7403 }
7404 double numerator = average; // interval
7405
7406
7407 sigma = LEP2sigmaMu(s);
7408
7409 AFB_noBox = numerator/sigma;
7410 }
7411 SMresult_cache = AFB_noBox;
7412
7413 if (flagLEP2[WeakBox]) {
7414 // numerator
7415 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7416 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7417 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7418 }
7419 double sigma_box_F = average; // interval
7420 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7421 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7422 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7423 }
7424 double sigma_box_B = average; // interval
7425
7426 // denominator
7427 if (!flagLEP2[ISR]) {
7428
7429 sigma = LEP2sigmaMu(s);
7430 }
7431
7432 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7433 }
7434 } else if (s == 207.*207.) {
7435 double AFB_noBox, sigma = 0.0;
7436 if (!flagLEP2[ISR])
7437 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7438 else {
7439 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu207, &(*this), _1));
7440 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7441 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7442 }
7443 double numerator = average; // interval
7444
7445
7446 sigma = LEP2sigmaMu(s);
7447
7448 AFB_noBox = numerator/sigma;
7449 }
7450 SMresult_cache = AFB_noBox;
7451
7452 if (flagLEP2[WeakBox]) {
7453 // numerator
7454 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7455 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7456 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7457 }
7458 double sigma_box_F = average; // interval
7459 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7460 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7461 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7462 }
7463 double sigma_box_B = average; // interval
7464
7465 // denominator
7466 if (!flagLEP2[ISR]) {
7467
7468 sigma = LEP2sigmaMu(s);
7469 }
7470
7471 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7472 }
7473 } else {
7474 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::AFBmu!");
7475 }
7476
7477 double AFBmu = SMresult_cache;
7478
7479 gsl_set_error_handler(old_handler);
7480 bSigmaForAFB = false;
7481 return AFBmu;
7482 }
7483}
double LEP2AFBmuApprox(const double s) const
The forward-backward asymmetry at LEP2.
const double getIntegrand_dsigmaBox_mu200(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu192(double x) const
const double getIntegrand_dsigmaBox_mu207(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu207(double x) const
const double getIntegrand_dsigmaBox_mu136(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu196(double x) const
const double getIntegrand_dsigmaBox_mu189(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu136(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu130(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu172(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu202(double x) const
const double getIntegrand_dsigmaBox_mu161(double x) const
const double getIntegrand_dsigmaBox_mu183(double x) const
const double getIntegrand_dsigmaBox_mu172(double x) const
const double getIntegrand_dsigmaBox_mu192(double x) const
const double getIntegrand_dsigmaBox_mu196(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu205(double x) const
const double getIntegrand_dsigmaBox_mu202(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu189(double x) const
virtual const double LEP2sigmaMu(const double s) const
const double getIntegrand_dsigmaBox_mu205(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu200(double x) const
const double AFB_NoISR_l(const QCD::lepton l_flavor, const double s) const
const double getIntegrand_AFBnumeratorWithISR_mu161(double x) const
const double getIntegrand_dsigmaBox_mu130(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu183(double x) const

◆ LEP2AFBtau()

const double StandardModel::LEP2AFBtau ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 7486 of file StandardModel/src/StandardModel.cpp.

7487{
7488
7489 bSigmaForAFB = true;
7490 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
7491 double relerr = 1.e-7;
7492 double abserr = 1.e-17;
7493
7494 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
7496
7497 /* SM contribution with the approximate formula */
7499
7500 } else {
7501
7502 if(s == 130.*130.){
7503 double AFB_noBox, sigma = 0.0;
7504 if (!flagLEP2[ISR])
7505 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7506 else {
7507 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau130, &(*this), _1));
7508 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7509 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7510 }
7511 double numerator = average; // interval
7512
7513
7514 sigma = LEP2sigmaTau(s);
7515
7516 AFB_noBox = numerator/sigma;
7517 }
7518 SMresult_cache = AFB_noBox;
7519
7520 if (flagLEP2[WeakBox]) {
7521 // numerator
7522 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7523 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7524 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7525 }
7526 double sigma_box_F = average; // interval
7527 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7528 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7529 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7530 }
7531 double sigma_box_B = average; // interval
7532
7533 // denominator
7534 if (!flagLEP2[ISR]) {
7535
7536 sigma = LEP2sigmaTau(s);
7537 }
7538
7539 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7540 }
7541 } else if (s == 136.*136.){
7542 double AFB_noBox, sigma = 0.0;
7543 if (!flagLEP2[ISR])
7544 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7545 else {
7546 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau136, &(*this), _1));
7547 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7548 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7549 }
7550 double numerator = average; // interval
7551
7552
7553 sigma = LEP2sigmaTau(s);
7554
7555 AFB_noBox = numerator/sigma;
7556 }
7557 SMresult_cache = AFB_noBox;
7558
7559 if (flagLEP2[WeakBox]) {
7560 // numerator
7561 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7562 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7563 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7564 }
7565 double sigma_box_F = average; // interval
7566 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7567 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7568 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7569 }
7570 double sigma_box_B = average; // interval
7571
7572 // denominator
7573 if (!flagLEP2[ISR]) {
7574
7575 sigma = LEP2sigmaTau(s);
7576 }
7577
7578 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7579 }
7580 } else if (s == 161.*161.){
7581 double AFB_noBox, sigma = 0.0;
7582 if (!flagLEP2[ISR])
7583 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7584 else {
7585 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau161, &(*this), _1));
7586 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7587 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7588 }
7589 double numerator = average; // interval
7590
7591
7592 sigma = LEP2sigmaTau(s);
7593
7594 AFB_noBox = numerator/sigma;
7595 }
7596 SMresult_cache = AFB_noBox;
7597
7598 if (flagLEP2[WeakBox]) {
7599 // numerator
7600 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7601 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7602 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7603 }
7604 double sigma_box_F = average; // interval
7605 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7606 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7607 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7608 }
7609 double sigma_box_B = average; // interval
7610
7611 // denominator
7612 if (!flagLEP2[ISR]) {
7613
7614 sigma = LEP2sigmaTau(s);
7615 }
7616
7617 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7618 }
7619 } else if (s == 172.*172.){
7620 double AFB_noBox, sigma = 0.0;
7621 if (!flagLEP2[ISR])
7622 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7623 else {
7624 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau172, &(*this), _1));
7625 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7626 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7627 }
7628 double numerator = average; // interval
7629
7630
7631 sigma = LEP2sigmaTau(s);
7632
7633 AFB_noBox = numerator/sigma;
7634 }
7635 SMresult_cache = AFB_noBox;
7636
7637 if (flagLEP2[WeakBox]) {
7638 // numerator
7639 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7640 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7641 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7642 }
7643 double sigma_box_F = average; // interval
7644 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7645 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7646 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7647 }
7648 double sigma_box_B = average; // interval
7649
7650 // denominator
7651 if (!flagLEP2[ISR]) {
7652
7653 sigma = LEP2sigmaTau(s);
7654 }
7655
7656 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7657 }
7658 } else if (s == 183.*183.) {
7659 double AFB_noBox, sigma = 0.0;
7660 if (!flagLEP2[ISR])
7661 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7662 else {
7663 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau183, &(*this), _1));
7664 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7665 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7666 }
7667 double numerator = average; // interval
7668
7669
7670 sigma = LEP2sigmaTau(s);
7671
7672 AFB_noBox = numerator/sigma;
7673 }
7674 SMresult_cache = AFB_noBox;
7675
7676 if (flagLEP2[WeakBox]) {
7677 // numerator
7678 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7679 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7680 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7681 }
7682 double sigma_box_F = average; // interval
7683 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7684 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7685 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7686 }
7687 double sigma_box_B = average; // interval
7688
7689 // denominator
7690 if (!flagLEP2[ISR]) {
7691
7692 sigma = LEP2sigmaTau(s);
7693 }
7694
7695 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7696 }
7697 } else if (s == 189.*189.) {
7698 double AFB_noBox, sigma = 0.0;
7699 if (!flagLEP2[ISR])
7700 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7701 else {
7702 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau189, &(*this), _1));
7703 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7704 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7705 }
7706 double numerator = average; // interval
7707
7708
7709 sigma = LEP2sigmaTau(s);
7710
7711 AFB_noBox = numerator/sigma;
7712 }
7713 SMresult_cache = AFB_noBox;
7714
7715 if (flagLEP2[WeakBox]) {
7716 // numerator
7717 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7718 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7719 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7720 }
7721 double sigma_box_F = average; // interval
7722 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7723 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7724 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7725 }
7726 double sigma_box_B = average; // interval
7727
7728 // denominator
7729 if (!flagLEP2[ISR]) {
7730
7731 sigma = LEP2sigmaTau(s);
7732 }
7733
7734 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7735 }
7736 } else if (s == 192.*192.) {
7737 double AFB_noBox, sigma = 0.0;
7738 if (!flagLEP2[ISR])
7739 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7740 else {
7741 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau192, &(*this), _1));
7742 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7743 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7744 }
7745 double numerator = average; // interval
7746
7747
7748 sigma = LEP2sigmaTau(s);
7749
7750 AFB_noBox = numerator/sigma;
7751 }
7752 SMresult_cache = AFB_noBox;
7753
7754 if (flagLEP2[WeakBox]) {
7755 // numerator
7756 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7757 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7758 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7759 }
7760 double sigma_box_F = average; // interval
7761 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7762 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7763 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7764 }
7765 double sigma_box_B = average; // interval
7766
7767 // denominator
7768 if (!flagLEP2[ISR]) {
7769
7770 sigma = LEP2sigmaTau(s);
7771 }
7772
7773 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7774 }
7775 } else if (s == 196.*196.) {
7776 double AFB_noBox, sigma = 0.0;
7777 if (!flagLEP2[ISR])
7778 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7779 else {
7780 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau196, &(*this), _1));
7781 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7782 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7783 }
7784 double numerator = average; // interval
7785
7786
7787 sigma = LEP2sigmaTau(s);
7788
7789 AFB_noBox = numerator/sigma;
7790 }
7791 SMresult_cache = AFB_noBox;
7792
7793 if (flagLEP2[WeakBox]) {
7794 // numerator
7795 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7796 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7797 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7798 }
7799 double sigma_box_F = average; // interval
7800 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7801 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7802 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7803 }
7804 double sigma_box_B = average; // interval
7805
7806 // denominator
7807 if (!flagLEP2[ISR]) {
7808
7809 sigma = LEP2sigmaTau(s);
7810 }
7811
7812 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7813 }
7814 } else if (s == 200.*200.) {
7815 double AFB_noBox, sigma = 0.0;
7816 if (!flagLEP2[ISR])
7817 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7818 else {
7819 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau200, &(*this), _1));
7820 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7821 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7822 }
7823 double numerator = average; // interval
7824
7825
7826 sigma = LEP2sigmaTau(s);
7827
7828 AFB_noBox = numerator/sigma;
7829 }
7830 SMresult_cache = AFB_noBox;
7831
7832 if (flagLEP2[WeakBox]) {
7833 // numerator
7834 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7835 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7836 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7837 }
7838 double sigma_box_F = average; // interval
7839 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7840 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7841 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7842 }
7843 double sigma_box_B = average; // interval
7844
7845 // denominator
7846 if (!flagLEP2[ISR]) {
7847
7848 sigma = LEP2sigmaTau(s);
7849 }
7850
7851 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7852 }
7853 } else if (s == 202.*202.) {
7854 double AFB_noBox, sigma = 0.0;
7855 if (!flagLEP2[ISR])
7856 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7857 else {
7858 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau202, &(*this), _1));
7859 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7860 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7861 }
7862 double numerator = average; // interval
7863
7864
7865 sigma = LEP2sigmaTau(s);
7866
7867 AFB_noBox = numerator/sigma;
7868 }
7869 SMresult_cache = AFB_noBox;
7870
7871 if (flagLEP2[WeakBox]) {
7872 // numerator
7873 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7874 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7875 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7876 }
7877 double sigma_box_F = average; // interval
7878 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7879 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7880 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7881 }
7882 double sigma_box_B = average; // interval
7883
7884 // denominator
7885 if (!flagLEP2[ISR]) {
7886
7887 sigma = LEP2sigmaTau(s);
7888 }
7889
7890 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7891 }
7892 } else if (s == 205.*205.) {
7893 double AFB_noBox, sigma = 0.0;
7894 if (!flagLEP2[ISR])
7895 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7896 else {
7897 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau205, &(*this), _1));
7898 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7899 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7900 }
7901 double numerator = average; // interval
7902
7903
7904 sigma = LEP2sigmaTau(s);
7905
7906 AFB_noBox = numerator/sigma;
7907 }
7908 SMresult_cache = AFB_noBox;
7909
7910 if (flagLEP2[WeakBox]) {
7911 // numerator
7912 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7913 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7914 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7915 }
7916 double sigma_box_F = average; // interval
7917 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7918 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7919 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7920 }
7921 double sigma_box_B = average; // interval
7922
7923 // denominator
7924 if (!flagLEP2[ISR]) {
7925
7926 sigma = LEP2sigmaTau(s);
7927 }
7928
7929 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7930 }
7931 } else if (s == 207.*207.) {
7932 double AFB_noBox, sigma = 0.0;
7933 if (!flagLEP2[ISR])
7934 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7935 else {
7936 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau207, &(*this), _1));
7937 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7938 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7939 }
7940 double numerator = average; // interval
7941
7942
7943 sigma = LEP2sigmaTau(s);
7944
7945 AFB_noBox = numerator/sigma;
7946 }
7947 SMresult_cache = AFB_noBox;
7948
7949 if (flagLEP2[WeakBox]) {
7950 // numerator
7951 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7952 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7953 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7954 }
7955 double sigma_box_F = average; // interval
7956 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7957 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7958 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7959 }
7960 double sigma_box_B = average; // interval
7961
7962 // denominator
7963 if (!flagLEP2[ISR]) {
7964
7965 sigma = LEP2sigmaTau(s);
7966 }
7967
7968 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7969 }
7970 } else {
7971 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBtau!");
7972 }
7973
7974 double AFBtau = SMresult_cache;
7975
7976 gsl_set_error_handler(old_handler);
7977 bSigmaForAFB = false;
7978 return AFBtau;
7979 }
7980}
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBlepton.h:160
double LEP2AFBtauApprox(const double s) const
The forward-backward asymmetry at LEP2.
const double getIntegrand_AFBnumeratorWithISR_tau130(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau200(double x) const
const double getIntegrand_dsigmaBox_tau136(double x) const
virtual const double LEP2sigmaTau(const double s) const
const double getIntegrand_AFBnumeratorWithISR_tau172(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau192(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau196(double x) const
const double getIntegrand_dsigmaBox_tau183(double x) const
const double getIntegrand_dsigmaBox_tau196(double x) const
const double getIntegrand_dsigmaBox_tau192(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau136(double x) const
const double getIntegrand_dsigmaBox_tau189(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau183(double x) const
const double getIntegrand_dsigmaBox_tau202(double x) const
const double getIntegrand_dsigmaBox_tau172(double x) const
const double getIntegrand_dsigmaBox_tau200(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau202(double x) const
const double getIntegrand_dsigmaBox_tau161(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau207(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau205(double x) const
const double getIntegrand_dsigmaBox_tau207(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau189(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau161(double x) const
const double getIntegrand_dsigmaBox_tau130(double x) const
const double getIntegrand_dsigmaBox_tau205(double x) const

◆ LEP2dsigmadcosBinE()

const double StandardModel::LEP2dsigmadcosBinE ( const double  s,
const double  cos,
const double  cosmin,
const double  cosmax 
) const
virtual

Reimplemented in NPbase.

Definition at line 9652 of file StandardModel/src/StandardModel.cpp.

9653{
9654 return LEP2dsigmadcosE(s, cos);
9655}
virtual const double LEP2dsigmadcosE(const double s, const double cos) const

◆ LEP2dsigmadcosBinMu()

const double StandardModel::LEP2dsigmadcosBinMu ( const double  s,
const double  cos,
const double  cosmin,
const double  cosmax 
) const
virtual

Reimplemented in NPbase.

Definition at line 9657 of file StandardModel/src/StandardModel.cpp.

9658{
9659 return LEP2dsigmadcosMu(s, cos);
9660}
virtual const double LEP2dsigmadcosMu(const double s, const double cos) const

◆ LEP2dsigmadcosBinTau()

const double StandardModel::LEP2dsigmadcosBinTau ( const double  s,
const double  cos,
const double  cosmin,
const double  cosmax 
) const
virtual

Reimplemented in NPbase.

Definition at line 9662 of file StandardModel/src/StandardModel.cpp.

9663{
9664 return LEP2dsigmadcosTau(s, cos);
9665}
virtual const double LEP2dsigmadcosTau(const double s, const double cos) const

◆ LEP2dsigmadcosE()

const double StandardModel::LEP2dsigmadcosE ( const double  s,
const double  cos 
) const
virtual

Reimplemented in NPbase.

Definition at line 9610 of file StandardModel/src/StandardModel.cpp.

9611{
9612 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9614
9615 /* SM contribution with the approximate formula */
9617
9618 } else {
9619 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosE only implemented via semi-analytical approx");
9620 }
9621}
double LEP2dsigmadcosEApprox(const double s, const double cos) const
The differential cross section at LEP2.

◆ LEP2dsigmadcosMu()

const double StandardModel::LEP2dsigmadcosMu ( const double  s,
const double  cos 
) const
virtual

Reimplemented in NPbase.

Definition at line 9623 of file StandardModel/src/StandardModel.cpp.

9624{
9625 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9627
9628 /* SM contribution with the approximate formula */
9630
9631 } else {
9632 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosMu only implemented via semi-analytical approx");
9633 }
9634}
double LEP2dsigmadcosMuApprox(const double s, const double cos) const
The differential cross section at LEP2.

◆ LEP2dsigmadcosTau()

const double StandardModel::LEP2dsigmadcosTau ( const double  s,
const double  cos 
) const
virtual

Reimplemented in NPbase.

Definition at line 9636 of file StandardModel/src/StandardModel.cpp.

9637{
9638 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9640
9641 /* SM contribution with the approximate formula */
9643
9644 } else {
9645 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosTau only implemented via semi-analytical approx");
9646 }
9647}
double LEP2dsigmadcosTauApprox(const double s, const double cos) const
The differential cross section at LEP2.

◆ LEP2Rbottom()

const double StandardModel::LEP2Rbottom ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 7983 of file StandardModel/src/StandardModel.cpp.

7984{
7985
7986 double sigma_b = LEP2sigmaBottom(s);
7987 double sigma_had = LEP2sigmaHadron(s);
7988 SMresult_cache = sigma_b / sigma_had;
7989 double R_bottom = SMresult_cache;
7990
7991 return R_bottom;
7992}
virtual const double LEP2sigmaHadron(const double s) const

◆ LEP2Rcharm()

const double StandardModel::LEP2Rcharm ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 7995 of file StandardModel/src/StandardModel.cpp.

7996{
7997
7998 double sigma_c = LEP2sigmaCharm(s);
7999 double sigma_had = LEP2sigmaHadron(s);
8000 SMresult_cache = sigma_c / sigma_had;
8001 double R_charm = SMresult_cache;
8002
8003 return R_charm;
8004}

◆ LEP2sigmaBottom()

const double StandardModel::LEP2sigmaBottom ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 4820 of file StandardModel/src/StandardModel.cpp.

4821{
4822 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4823 double relerr = 1.e-8;
4824 double abserr = 1.e-20;
4825
4826 if(s == 133.*133.){
4827
4828 if (!flagLEP2[ISR]){
4830 } else {
4831 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
4832 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4833 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4834 }
4836 }
4837
4838 if (flagLEP2[WeakBox]) {
4839 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
4840 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4841 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4842 }
4843 double sigma_box = average;
4844 SMresult_cache += sigma_box;
4845 }
4846 } else if (s == 167.*167.){
4847 if (!flagLEP2[ISR])
4849 else {
4850 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
4851 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4852 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4853 }
4855 }
4856
4857 if (flagLEP2[WeakBox]) {
4858 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
4859 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4860 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4861 }
4862 double sigma_box = average;
4863 SMresult_cache += sigma_box;
4864 }
4865 } else if (s == 183.*183.) {
4866 if (!flagLEP2[ISR])
4868 else {
4869 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
4870 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4871 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4872 }
4874 }
4875
4876 if (flagLEP2[WeakBox]) {
4877 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
4878 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4879 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4880 }
4881 double sigma_box = average;
4882 SMresult_cache += sigma_box;
4883 }
4884 } else if (s == 189.*189.) {
4885 if (!flagLEP2[ISR])
4887 else {
4888 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
4889 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4890 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4891 }
4893 }
4894
4895 if (flagLEP2[WeakBox]) {
4896 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
4897 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4898 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4899 }
4900 double sigma_box = average;
4901 SMresult_cache += sigma_box;
4902 }
4903 } else if (s == 192.*192.) {
4904 if (!flagLEP2[ISR])
4906 else {
4907 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
4908 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4909 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4910 }
4912 }
4913
4914 if (flagLEP2[WeakBox]) {
4915 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
4916 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4917 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4918 }
4919 double sigma_box = average;
4920 SMresult_cache += sigma_box;
4921 }
4922 } else if (s == 196.*196.) {
4923 if (!flagLEP2[ISR])
4925 else {
4926 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
4927 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4928 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4929 }
4931 }
4932
4933 if (flagLEP2[WeakBox]) {
4934 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
4935 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4936 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4937 }
4938 double sigma_box = average;
4939 SMresult_cache += sigma_box;
4940 }
4941 } else if (s == 200.*200.) {
4942 if (!flagLEP2[ISR])
4944 else {
4945 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
4946 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4947 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4948 }
4950 }
4951
4952 if (flagLEP2[WeakBox]) {
4953 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
4954 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4955 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4956 }
4957 double sigma_box = average;
4958 SMresult_cache += sigma_box;
4959 }
4960 } else if (s == 202.*202.) {
4961 if (!flagLEP2[ISR])
4963 else {
4964 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
4965 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4966 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4967 }
4969 }
4970
4971 if (flagLEP2[WeakBox]) {
4972 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
4973 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4974 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4975 }
4976 double sigma_box = average;
4977 SMresult_cache += sigma_box;
4978 }
4979 } else if (s == 205.*205.) {
4980 if (!flagLEP2[ISR])
4982 else {
4983 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
4984 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4985 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4986 }
4988 }
4989
4990 if (flagLEP2[WeakBox]) {
4991 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
4992 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4993 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4994 }
4995 double sigma_box = average;
4996 SMresult_cache += sigma_box;
4997 }
4998 } else if (s == 207.*207.) {
4999 if (!flagLEP2[ISR])
5001 else {
5002 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
5003 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5004 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5005 }
5007 }
5008
5009 if (flagLEP2[WeakBox]) {
5010 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
5011 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5012 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5013 }
5014 double sigma_box = average;
5015 SMresult_cache += sigma_box;
5016 }
5017 } else {
5018 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaBottom!");
5019 }
5020
5021
5022 double sigma_mu = SMresult_cache;
5023
5024 gsl_set_error_handler(old_handler);
5025
5026 return sigma_mu;
5027
5028}
const double getIntegrand_sigmaWithISR_bottom200(double x) const
const double getIntegrand_sigmaWithISR_bottom207(double x) const
const double getIntegrand_sigmaWithISR_bottom192(double x) const
const double sigma_NoISR_q(const QCD::quark q_flavor, const double s) const
const double getIntegrand_sigmaWithISR_bottom196(double x) const
const double getIntegrand_sigmaWithISR_bottom205(double x) const
const double getIntegrand_sigmaWithISR_bottom133(double x) const
const double getIntegrand_sigmaWithISR_bottom202(double x) const
const double getIntegrand_sigmaWithISR_bottom167(double x) const
const double getIntegrand_sigmaWithISR_bottom183(double x) const
const double getIntegrand_sigmaWithISR_bottom189(double x) const

◆ LEP2sigmaCharm()

const double StandardModel::LEP2sigmaCharm ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 4609 of file StandardModel/src/StandardModel.cpp.

4610{
4611 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4612 double relerr = 1.e-8;
4613 double abserr = 1.e-20;
4614
4615 if(s == 133.*133.){
4616
4617 if (!flagLEP2[ISR]){
4619 } else {
4620 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
4621 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4622 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4623 }
4625 }
4626
4627 if (flagLEP2[WeakBox]) {
4628 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
4629 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4630 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4631 }
4632 double sigma_box = average;
4633 SMresult_cache += sigma_box;
4634 }
4635 } else if (s == 167.*167.){
4636 if (!flagLEP2[ISR])
4638 else {
4639 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
4640 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4641 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4642 }
4644 }
4645
4646 if (flagLEP2[WeakBox]) {
4647 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
4648 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4649 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4650 }
4651 double sigma_box = average;
4652 SMresult_cache += sigma_box;
4653 }
4654 } else if (s == 183.*183.) {
4655 if (!flagLEP2[ISR])
4657 else {
4658 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
4659 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4660 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4661 }
4663 }
4664
4665 if (flagLEP2[WeakBox]) {
4666 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
4667 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4668 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4669 }
4670 double sigma_box = average;
4671 SMresult_cache += sigma_box;
4672 }
4673 } else if (s == 189.*189.) {
4674 if (!flagLEP2[ISR])
4676 else {
4677 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
4678 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4679 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4680 }
4682 }
4683
4684 if (flagLEP2[WeakBox]) {
4685 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
4686 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4687 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4688 }
4689 double sigma_box = average;
4690 SMresult_cache += sigma_box;
4691 }
4692 } else if (s == 192.*192.) {
4693 if (!flagLEP2[ISR])
4695 else {
4696 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
4697 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4698 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4699 }
4701 }
4702
4703 if (flagLEP2[WeakBox]) {
4704 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
4705 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4706 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4707 }
4708 double sigma_box = average;
4709 SMresult_cache += sigma_box;
4710 }
4711 } else if (s == 196.*196.) {
4712 if (!flagLEP2[ISR])
4714 else {
4715 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
4716 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4717 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4718 }
4720 }
4721
4722 if (flagLEP2[WeakBox]) {
4723 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
4724 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4725 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4726 }
4727 double sigma_box = average;
4728 SMresult_cache += sigma_box;
4729 }
4730 } else if (s == 200.*200.) {
4731 if (!flagLEP2[ISR])
4733 else {
4734 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
4735 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4736 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4737 }
4739 }
4740
4741 if (flagLEP2[WeakBox]) {
4742 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
4743 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4744 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4745 }
4746 double sigma_box = average;
4747 SMresult_cache += sigma_box;
4748 }
4749 } else if (s == 202.*202.) {
4750 if (!flagLEP2[ISR])
4752 else {
4753 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
4754 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4755 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4756 }
4758 }
4759
4760 if (flagLEP2[WeakBox]) {
4761 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
4762 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4763 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4764 }
4765 double sigma_box = average;
4766 SMresult_cache += sigma_box;
4767 }
4768 } else if (s == 205.*205.) {
4769 if (!flagLEP2[ISR])
4771 else {
4772 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
4773 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4774 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4775 }
4777 }
4778
4779 if (flagLEP2[WeakBox]) {
4780 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
4781 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4782 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4783 }
4784 double sigma_box = average;
4785 SMresult_cache += sigma_box;
4786 }
4787 } else if (s == 207.*207.) {
4788 if (!flagLEP2[ISR])
4790 else {
4791 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
4792 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4793 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4794 }
4796 }
4797
4798 if (flagLEP2[WeakBox]) {
4799 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
4800 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4801 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4802 }
4803 double sigma_box = average;
4804 SMresult_cache += sigma_box;
4805 }
4806 } else {
4807 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaCharm!");
4808 }
4809
4810
4811 double sigma_mu = SMresult_cache;
4812
4813 gsl_set_error_handler(old_handler);
4814
4815 return sigma_mu;
4816
4817}
const double getIntegrand_sigmaWithISR_charm192(double x) const
const double getIntegrand_sigmaWithISR_charm183(double x) const
const double getIntegrand_sigmaWithISR_charm205(double x) const
const double getIntegrand_sigmaWithISR_charm207(double x) const
const double getIntegrand_sigmaWithISR_charm202(double x) const
const double getIntegrand_sigmaWithISR_charm200(double x) const
const double getIntegrand_sigmaWithISR_charm133(double x) const
const double getIntegrand_sigmaWithISR_charm167(double x) const
const double getIntegrand_sigmaWithISR_charm196(double x) const
const double getIntegrand_sigmaWithISR_charm189(double x) const

◆ LEP2sigmaE()

const double StandardModel::LEP2sigmaE ( const double  s) const
virtual

Reimplemented in NPbase.

Definition at line 4089 of file StandardModel/src/StandardModel.cpp.

4090{
4091 return 0.;
4092}

◆ LEP2sigmaHadron()

const double StandardModel::LEP2sigmaHadron ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 5031 of file StandardModel/src/StandardModel.cpp.

5032{
5033 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
5034 double relerr = 1.e-8;
5035 double abserr = 1.e-20;
5036
5037 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
5039
5040 /* SM contribution with the approximate formula */
5042
5043 } else {
5044
5045 if(s == 130.*130.){
5046
5047 if (!flagLEP2[ISR]){
5053 } else {
5054
5055 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up130, &(*this), _1));
5056 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5057 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5058 }
5060
5061 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down130, &(*this), _1));
5062 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5063 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5064 }
5066
5067 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm130, &(*this), _1));
5068 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5069 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5070 }
5072
5073 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange130, &(*this), _1));
5074 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5075 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5076 }
5078
5079 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom130, &(*this), _1));
5080 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5081 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5082 }
5084
5085 }
5086
5087 if (flagLEP2[WeakBox]) {
5088 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up130, &(*this), _1));
5089 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5090 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5091 }
5092 double sigma_box = average;
5093
5094 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down130, &(*this), _1));
5095 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5096 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5097 }
5098 sigma_box += average;
5099
5100 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm130, &(*this), _1));
5101 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5102 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5103 }
5104 sigma_box += average;
5105
5106 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange130, &(*this), _1));
5107 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5108 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5109 }
5110 sigma_box += average;
5111
5112 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom130, &(*this), _1));
5113 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5114 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5115 }
5116 sigma_box += average;
5117 SMresult_cache += sigma_box;
5118 }
5119 } else if (s == 133.*133.) {
5120 if (!flagLEP2[ISR]){
5126 } else {
5127
5128 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up133, &(*this), _1));
5129 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5130 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5131 }
5133
5134 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down133, &(*this), _1));
5135 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5136 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5137 }
5139
5140 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
5141 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5142 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5143 }
5145
5146 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange133, &(*this), _1));
5147 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5148 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5149 }
5151
5152 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
5153 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5154 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5155 }
5157 }
5158
5159 if (flagLEP2[WeakBox]) {
5160 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up133, &(*this), _1));
5161 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5162 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5163 }
5164 double sigma_box = average;
5165
5166 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down133, &(*this), _1));
5167 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5168 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5169 }
5170 sigma_box += average;
5171
5172 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
5173 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5174 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5175 }
5176 sigma_box += average;
5177
5178 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange133, &(*this), _1));
5179 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5180 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5181 }
5182 sigma_box += average;
5183
5184 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
5185 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5186 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5187 }
5188 sigma_box += average;
5189 SMresult_cache += sigma_box;
5190 }
5191 } else if (s == 136.*136.) {
5192 if (!flagLEP2[ISR]){
5198 } else {
5199
5200 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up136, &(*this), _1));
5201 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5202 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5203 }
5205
5206 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down136, &(*this), _1));
5207 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5208 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5209 }
5211
5212 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm136, &(*this), _1));
5213 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5214 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5215 }
5217
5218 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange136, &(*this), _1));
5219 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5220 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5221 }
5223
5224 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom136, &(*this), _1));
5225 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5226 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5227 }
5229 }
5230
5231 if (flagLEP2[WeakBox]) {
5232 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up136, &(*this), _1));
5233 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5234 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5235 }
5236 double sigma_box = average;
5237
5238 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down136, &(*this), _1));
5239 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5240 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5241 }
5242 sigma_box += average;
5243
5244 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm136, &(*this), _1));
5245 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5246 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5247 }
5248 sigma_box += average;
5249
5250 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange136, &(*this), _1));
5251 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5252 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5253 }
5254 sigma_box += average;
5255
5256 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom136, &(*this), _1));
5257 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5258 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5259 }
5260 sigma_box += average;
5261 SMresult_cache += sigma_box;
5262 }
5263 } else if (s == 161.*161.){
5264 if (!flagLEP2[ISR]){
5270 } else {
5271
5272 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up161, &(*this), _1));
5273 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5274 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5275 }
5277
5278 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down161, &(*this), _1));
5279 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5280 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5281 }
5283
5284 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm161, &(*this), _1));
5285 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-12, 1.e-6, 100, w_GSL1, &average, &error) != 0){
5286 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5287 }
5289
5290 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange161, &(*this), _1));
5291 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 200, w_GSL1, &average, &error) != 0){
5292 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5293 }
5295
5296 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom161, &(*this), _1));
5297 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5298 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5299 }
5301 }
5302
5303 if (flagLEP2[WeakBox]) {
5304 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up161, &(*this), _1));
5305 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5306 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5307 }
5308 double sigma_box = average;
5309
5310 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down161, &(*this), _1));
5311 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5312 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5313 }
5314 sigma_box += average;
5315
5316 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm161, &(*this), _1));
5317 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5318 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5319 }
5320 sigma_box += average;
5321
5322 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange161, &(*this), _1));
5323 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5324 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5325 }
5326 sigma_box += average;
5327
5328 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom161, &(*this), _1));
5329 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5330 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5331 }
5332 sigma_box += average;
5333 SMresult_cache += sigma_box;
5334 }
5335 } else if (s == 167.*167.) {
5336 if (!flagLEP2[ISR]){
5342 } else {
5343
5344 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up167, &(*this), _1));
5345 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5346 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5347 }
5348
5350
5351 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down167, &(*this), _1));
5352 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5353 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5354 }
5356
5357 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
5358 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5359 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5360 }
5362
5363 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange167, &(*this), _1));
5364 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5365 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5366 }
5368
5369 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
5370 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5371 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5372 }
5374 }
5375
5376 if (flagLEP2[WeakBox]) {
5377 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up167, &(*this), _1));
5378 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5379 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5380 }
5381 double sigma_box = average;
5382
5383 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down167, &(*this), _1));
5384 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5385 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5386 }
5387 sigma_box += average;
5388
5389 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
5390 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5391 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5392 }
5393 sigma_box += average;
5394
5395 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange167, &(*this), _1));
5396 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5397 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5398 }
5399 sigma_box += average;
5400
5401 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
5402 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5403 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5404 }
5405 sigma_box += average;
5406 SMresult_cache += sigma_box;
5407 }
5408 } else if (s == 172.*172.) {
5409 if (!flagLEP2[ISR]){
5415 } else {
5416
5417 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up172, &(*this), _1));
5418 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5419 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5420 }
5422
5423 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down172, &(*this), _1));
5424 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5425 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5426 }
5428
5429 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm172, &(*this), _1));
5430 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5431 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5432 }
5434
5435 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange172, &(*this), _1));
5436 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5437 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5438 }
5440
5441 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom172, &(*this), _1));
5442 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5443 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5444 }
5446 }
5447
5448 if (flagLEP2[WeakBox]) {
5449 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up172, &(*this), _1));
5450 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5451 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5452 }
5453 double sigma_box = average;
5454
5455 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down172, &(*this), _1));
5456 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5457 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5458 }
5459 sigma_box += average;
5460
5461 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm172, &(*this), _1));
5462 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5463 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5464 }
5465 sigma_box += average;
5466
5467 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange172, &(*this), _1));
5468 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5469 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5470 }
5471 sigma_box += average;
5472
5473 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom172, &(*this), _1));
5474 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5475 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5476 }
5477 sigma_box += average;
5478 SMresult_cache += sigma_box;
5479 }
5480 } else if (s == 183.*183.) {
5481 if (!flagLEP2[ISR]){
5487 } else {
5488
5489 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up183, &(*this), _1));
5490 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5491 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5492 }
5494
5495 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down183, &(*this), _1));
5496 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5497 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5498 }
5500
5501 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
5502 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5503 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5504 }
5506
5507 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange183, &(*this), _1));
5508 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5509 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5510 }
5512
5513 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
5514 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5515 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5516 }
5518 }
5519
5520 if (flagLEP2[WeakBox]) {
5521 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up183, &(*this), _1));
5522 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5523 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5524 }
5525 double sigma_box = average;
5526
5527 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down183, &(*this), _1));
5528 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5529 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5530 }
5531 sigma_box += average;
5532
5533 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
5534 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5535 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5536 }
5537 sigma_box += average;
5538
5539 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange183, &(*this), _1));
5540 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5541 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5542 }
5543 sigma_box += average;
5544
5545 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
5546 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5547 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5548 }
5549 sigma_box += average;
5550 SMresult_cache += sigma_box;
5551 }
5552 } else if (s == 189.*189.) {
5553 if (!flagLEP2[ISR]){
5559 } else {
5560
5561 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up189, &(*this), _1));
5562 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5563 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5564 }
5566
5567 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down189, &(*this), _1));
5568 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5569 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5570 }
5572
5573 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
5574 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5575 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5576 }
5578
5579 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange189, &(*this), _1));
5580 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5581 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5582 }
5584
5585 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
5586 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5587 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5588 }
5590 }
5591
5592 if (flagLEP2[WeakBox]) {
5593 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up189, &(*this), _1));
5594 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5595 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5596 }
5597 double sigma_box = average;
5598
5599 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down189, &(*this), _1));
5600 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5601 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5602 }
5603 sigma_box += average;
5604
5605 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
5606 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5607 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5608 }
5609 sigma_box += average;
5610
5611 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange189, &(*this), _1));
5612 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5613 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5614 }
5615 sigma_box += average;
5616
5617 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
5618 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5619 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5620 }
5621 sigma_box += average;
5622 SMresult_cache += sigma_box;
5623 }
5624 } else if (s == 192.*192.) {
5625 if (!flagLEP2[ISR]){
5631 } else {
5632
5633 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up192, &(*this), _1));
5634 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5635 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5636 }
5638
5639 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down192, &(*this), _1));
5640 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5641 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5642 }
5644
5645 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
5646
5647 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5648 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5649 }
5651
5652 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange192, &(*this), _1));
5653
5654 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5655 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5656 }
5658
5659 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
5660 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5661 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5662 }
5664 }
5665
5666 if (flagLEP2[WeakBox]) {
5667 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up192, &(*this), _1));
5668 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5669 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5670 }
5671 double sigma_box = average;
5672
5673 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down192, &(*this), _1));
5674 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5675 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5676 }
5677 sigma_box += average;
5678
5679 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
5680 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5681 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5682 }
5683 sigma_box += average;
5684
5685 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange192, &(*this), _1));
5686 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5687 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5688 }
5689 sigma_box += average;
5690
5691 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
5692 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5693 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5694 }
5695 sigma_box += average;
5696 SMresult_cache += sigma_box;
5697 }
5698 } else if (s == 196.*196.) {
5699 if (!flagLEP2[ISR]){
5705 } else {
5706
5707 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up196, &(*this), _1));
5708 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5709 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5710 }
5712
5713 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down196, &(*this), _1));
5714 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5715 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5716 }
5718
5719 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
5720 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5721 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5722 }
5724
5725 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange196, &(*this), _1));
5726
5727 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5728 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5729 }
5731
5732 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
5733 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5734 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5735 }
5737 }
5738
5739 if (flagLEP2[WeakBox]) {
5740 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up196, &(*this), _1));
5741 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5742 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5743 }
5744 double sigma_box = average;
5745
5746 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down196, &(*this), _1));
5747 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5748 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5749 }
5750 sigma_box += average;
5751
5752 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
5753 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5754 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5755 }
5756 sigma_box += average;
5757
5758 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange196, &(*this), _1));
5759 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5760 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5761 }
5762 sigma_box += average;
5763
5764 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
5765 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5766 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5767 }
5768 sigma_box += average;
5769 SMresult_cache += sigma_box;
5770 }
5771 } else if (s == 200.*200.) {
5772 if (!flagLEP2[ISR]){
5778 } else {
5779
5780 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up200, &(*this), _1));
5781 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5782 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5783 }
5785
5786 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down200, &(*this), _1));
5787 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5788 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5789 }
5791
5792 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
5793 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5794 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5795 }
5797
5798 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange200, &(*this), _1));
5799 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5800 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5801 }
5803
5804 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
5805 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5806 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5807 }
5809 }
5810
5811 if (flagLEP2[WeakBox]) {
5812 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up200, &(*this), _1));
5813 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5814 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5815 }
5816 double sigma_box = average;
5817
5818 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down200, &(*this), _1));
5819 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5820 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5821 }
5822 sigma_box += average;
5823
5824 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
5825 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5826 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5827 }
5828 sigma_box += average;
5829
5830 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange200, &(*this), _1));
5831 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5832 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5833 }
5834 sigma_box += average;
5835
5836 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
5837 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5838 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5839 }
5840 sigma_box += average;
5841 SMresult_cache += sigma_box;
5842 }
5843 } else if (s == 202.*202.) {
5844 if (!flagLEP2[ISR]){
5850 } else {
5851
5852 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up202, &(*this), _1));
5853
5854
5855
5856 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5857 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5858 }
5860
5861 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down202, &(*this), _1));
5862
5863
5864
5865 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5866 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5867 }
5869
5870 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
5871
5872
5873
5874 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5875 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5876 }
5878
5879 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange202, &(*this), _1));
5880
5881
5882
5883 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5884 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5885 }
5887
5888 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
5889
5890
5891
5892 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5893 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5894 }
5896 }
5897
5898 if (flagLEP2[WeakBox]) {
5899 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up202, &(*this), _1));
5900
5901
5902
5903 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5904 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5905 }
5906 double sigma_box = average;
5907
5908 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down202, &(*this), _1));
5909
5910
5911
5912 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5913 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5914 }
5915 sigma_box += average;
5916
5917 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
5918
5919
5920
5921 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5922 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5923 }
5924 sigma_box += average;
5925
5926 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange202, &(*this), _1));
5927
5928
5929
5930 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5931 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5932 }
5933 sigma_box += average;
5934
5935 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
5936
5937
5938
5939 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5940 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5941 }
5942 sigma_box += average;
5943 SMresult_cache += sigma_box;
5944 }
5945 } else if (s == 205.*205.) {
5946 if (!flagLEP2[ISR]){
5952 } else {
5953
5954 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up205, &(*this), _1));
5955
5956
5957
5958 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5959 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5960 }
5962
5963 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down205, &(*this), _1));
5964
5965
5966
5967 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5968 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5969 }
5971
5972 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
5973
5974
5975
5976 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5977 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5978 }
5980
5981 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange205, &(*this), _1));
5982
5983
5984
5985 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5986 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5987 }
5989
5990 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
5991
5992
5993
5994 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5995 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5996 }
5998 }
5999
6000 if (flagLEP2[WeakBox]) {
6001 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up205, &(*this), _1));
6002
6003
6004
6005 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6006 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6007 }
6008 double sigma_box = average;
6009
6010 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down205, &(*this), _1));
6011
6012
6013
6014 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6015 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6016 }
6017 sigma_box += average;
6018
6019 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6020
6021
6022
6023 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6024 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6025 }
6026 sigma_box += average;
6027
6028 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange205, &(*this), _1));
6029
6030
6031
6032 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6033 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6034 }
6035 sigma_box += average;
6036
6037 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6038
6039
6040
6041 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6042 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6043 }
6044 sigma_box += average;
6045 SMresult_cache += sigma_box;
6046 }
6047 } else if (s == 207.*207.) {
6048 if (!flagLEP2[ISR]){
6054 } else {
6055
6056 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up207, &(*this), _1));
6057
6058
6059
6060 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6061 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6062 }
6064
6065 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down207, &(*this), _1));
6066
6067
6068
6069 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6070 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6071 }
6073
6074 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
6075
6076
6077
6078 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6079 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6080 }
6082
6083 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange207, &(*this), _1));
6084
6085
6086
6087 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6088 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6089 }
6091
6092 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
6093
6094
6095
6096 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6097 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6098 }
6100 }
6101
6102 if (flagLEP2[WeakBox]) {
6103 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up207, &(*this), _1));
6104
6105
6106
6107 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6108 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6109 }
6110 double sigma_box = average;
6111
6112 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down207, &(*this), _1));
6113
6114
6115
6116 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6117 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6118 }
6119 sigma_box += average;
6120
6121 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6122
6123
6124
6125 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6126 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6127 }
6128 sigma_box += average;
6129
6130 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange207, &(*this), _1));
6131
6132
6133
6134 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6135 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6136 }
6137 sigma_box += average;
6138
6139 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6140
6141
6142
6143 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6144 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6145 }
6146 sigma_box += average;
6147 SMresult_cache += sigma_box;
6148 }
6149 } else {
6150 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaHadron!");
6151 }
6152
6153 double sigma_had = SMresult_cache;
6154
6155 gsl_set_error_handler(old_handler);
6156
6157 return sigma_had;
6158
6159 }
6160}
double LEP2sigmaHadronApprox(const double s) const
The cross section at LEP2.
const double getIntegrand_sigmaWithISR_down183(double x) const
const double getIntegrand_dsigmaBox_strange167(double x) const
const double getIntegrand_sigmaWithISR_strange167(double x) const
const double getIntegrand_sigmaWithISR_strange189(double x) const
const double getIntegrand_sigmaWithISR_strange161(double x) const
const double getIntegrand_dsigmaBox_up130(double x) const
const double getIntegrand_dsigmaBox_down207(double x) const
const double getIntegrand_dsigmaBox_down200(double x) const
const double getIntegrand_dsigmaBox_strange172(double x) const
const double getIntegrand_dsigmaBox_up202(double x) const
const double getIntegrand_sigmaWithISR_down192(double x) const
const double getIntegrand_dsigmaBox_strange130(double x) const
const double getIntegrand_sigmaWithISR_strange136(double x) const
const double getIntegrand_sigmaWithISR_down207(double x) const
const double getIntegrand_dsigmaBox_down136(double x) const
const double getIntegrand_dsigmaBox_strange189(double x) const
const double getIntegrand_sigmaWithISR_up183(double x) const
const double getIntegrand_sigmaWithISR_strange183(double x) const
const double getIntegrand_dsigmaBox_down183(double x) const
const double getIntegrand_dsigmaBox_charm130(double x) const
const double getIntegrand_sigmaWithISR_strange200(double x) const
const double getIntegrand_sigmaWithISR_up167(double x) const
const double getIntegrand_sigmaWithISR_strange207(double x) const
const double getIntegrand_dsigmaBox_down161(double x) const
const double getIntegrand_dsigmaBox_strange207(double x) const
const double getIntegrand_sigmaWithISR_down202(double x) const
const double getIntegrand_dsigmaBox_charm161(double x) const
const double getIntegrand_dsigmaBox_up192(double x) const
const double getIntegrand_sigmaWithISR_strange202(double x) const
const double getIntegrand_dsigmaBox_down202(double x) const
const double getIntegrand_dsigmaBox_up200(double x) const
const double getIntegrand_sigmaWithISR_bottom136(double x) const
const double getIntegrand_sigmaWithISR_bottom130(double x) const
const double getIntegrand_sigmaWithISR_charm161(double x) const
const double getIntegrand_sigmaWithISR_charm172(double x) const
const double getIntegrand_dsigmaBox_up167(double x) const
const double getIntegrand_dsigmaBox_strange200(double x) const
const double getIntegrand_dsigmaBox_strange196(double x) const
const double getIntegrand_dsigmaBox_up207(double x) const
const double getIntegrand_sigmaWithISR_down200(double x) const
const double getIntegrand_sigmaWithISR_charm130(double x) const
const double getIntegrand_sigmaWithISR_down196(double x) const
const double getIntegrand_sigmaWithISR_bottom172(double x) const
const double getIntegrand_sigmaWithISR_up133(double x) const
const double getIntegrand_dsigmaBox_down189(double x) const
const double getIntegrand_sigmaWithISR_up172(double x) const
const double getIntegrand_dsigmaBox_up161(double x) const
const double getIntegrand_sigmaWithISR_strange205(double x) const
const double getIntegrand_dsigmaBox_bottom172(double x) const
const double getIntegrand_dsigmaBox_down133(double x) const
const double getIntegrand_dsigmaBox_down167(double x) const
const double getIntegrand_sigmaWithISR_strange133(double x) const
const double getIntegrand_sigmaWithISR_down130(double x) const
const double getIntegrand_sigmaWithISR_strange192(double x) const
const double getIntegrand_dsigmaBox_bottom130(double x) const
const double getIntegrand_sigmaWithISR_strange130(double x) const
const double getIntegrand_dsigmaBox_strange161(double x) const
const double getIntegrand_sigmaWithISR_down136(double x) const
const double getIntegrand_sigmaWithISR_up192(double x) const
const double getIntegrand_dsigmaBox_strange205(double x) const
const double getIntegrand_sigmaWithISR_up200(double x) const
const double getIntegrand_dsigmaBox_up183(double x) const
const double getIntegrand_dsigmaBox_strange183(double x) const
const double getIntegrand_dsigmaBox_up133(double x) const
const double getIntegrand_sigmaWithISR_strange172(double x) const
const double getIntegrand_dsigmaBox_strange202(double x) const
const double getIntegrand_sigmaWithISR_up189(double x) const
const double getIntegrand_dsigmaBox_down172(double x) const
const double getIntegrand_dsigmaBox_strange136(double x) const
const double getIntegrand_sigmaWithISR_up136(double x) const
const double getIntegrand_sigmaWithISR_strange196(double x) const
const double getIntegrand_dsigmaBox_up205(double x) const
const double getIntegrand_sigmaWithISR_up202(double x) const
const double getIntegrand_sigmaWithISR_down167(double x) const
const double getIntegrand_sigmaWithISR_down133(double x) const
const double getIntegrand_sigmaWithISR_charm136(double x) const
const double getIntegrand_dsigmaBox_down130(double x) const
const double getIntegrand_dsigmaBox_strange192(double x) const
const double getIntegrand_sigmaWithISR_down189(double x) const
const double getIntegrand_dsigmaBox_bottom161(double x) const
const double getIntegrand_sigmaWithISR_up207(double x) const
const double getIntegrand_dsigmaBox_charm172(double x) const
const double getIntegrand_dsigmaBox_charm136(double x) const
const double getIntegrand_sigmaWithISR_up205(double x) const
const double getIntegrand_dsigmaBox_down196(double x) const
const double getIntegrand_sigmaWithISR_up161(double x) const
const double getIntegrand_sigmaWithISR_down172(double x) const
const double getIntegrand_dsigmaBox_strange133(double x) const
const double getIntegrand_sigmaWithISR_up196(double x) const
const double getIntegrand_dsigmaBox_up196(double x) const
const double getIntegrand_sigmaWithISR_bottom161(double x) const
const double getIntegrand_dsigmaBox_up189(double x) const
const double getIntegrand_dsigmaBox_up136(double x) const
const double getIntegrand_sigmaWithISR_down205(double x) const
const double getIntegrand_dsigmaBox_up172(double x) const
const double getIntegrand_sigmaWithISR_up130(double x) const
const double getIntegrand_dsigmaBox_down205(double x) const
const double getIntegrand_dsigmaBox_down192(double x) const
const double getIntegrand_sigmaWithISR_down161(double x) const
const double getIntegrand_dsigmaBox_bottom136(double x) const

◆ LEP2sigmaMu()

const double StandardModel::LEP2sigmaMu ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 4094 of file StandardModel/src/StandardModel.cpp.

4095{
4096 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4097 double relerr = 1.e-8;
4098 double abserr = 1.e-20;
4099
4100 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4102
4103 /* SM contribution with the approximate formula */
4105
4106 } else {
4107
4108 if(s == 130.*130.){
4109
4110 if (!flagLEP2[ISR]){
4112 } else {
4113 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu130, &(*this), _1));
4114 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4115 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4116 }
4118 }
4119
4120 if (flagLEP2[WeakBox]) {
4121 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
4122 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4123 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4124 }
4125 double sigma_box = average;
4126 SMresult_cache += sigma_box;
4127 }
4128 } else if (s == 136.*136.) {
4129 if (!flagLEP2[ISR]){
4131 } else {
4132 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu136, &(*this), _1));
4133 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4134 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4135 }
4137 }
4138
4139 if (flagLEP2[WeakBox]) {
4140 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
4141 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4142 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4143 }
4144 double sigma_box = average;
4145 SMresult_cache += sigma_box;
4146 }
4147 } else if (s == 161.*161.){
4148 if (!flagLEP2[ISR])
4150 else {
4151 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu161, &(*this), _1));
4152 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4153 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4154 }
4156 }
4157
4158 if (flagLEP2[WeakBox]) {
4159 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
4160 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4161 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4162 }
4163 double sigma_box = average;
4164 SMresult_cache += sigma_box;
4165 }
4166 } else if (s == 172.*172.) {
4167 if (!flagLEP2[ISR])
4169 else {
4170 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu172, &(*this), _1));
4171 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4172 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4173 }
4175 }
4176
4177 if (flagLEP2[WeakBox]) {
4178 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
4179 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4180 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4181 }
4182 double sigma_box = average;
4183 SMresult_cache += sigma_box;
4184 }
4185 } else if (s == 183.*183.) {
4186 if (!flagLEP2[ISR])
4188 else {
4189 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu183, &(*this), _1));
4190 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4191 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4192 }
4194 }
4195
4196 if (flagLEP2[WeakBox]) {
4197 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
4198 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4199 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4200 }
4201 double sigma_box = average;
4202 SMresult_cache += sigma_box;
4203 }
4204 } else if (s == 189.*189.) {
4205 if (!flagLEP2[ISR])
4207 else {
4208 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu189, &(*this), _1));
4209 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4210 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4211 }
4213 }
4214
4215 if (flagLEP2[WeakBox]) {
4216 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
4217 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4218 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4219 }
4220 double sigma_box = average;
4221 SMresult_cache += sigma_box;
4222 }
4223 } else if (s == 192.*192.) {
4224 if (!flagLEP2[ISR])
4226 else {
4227 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu192, &(*this), _1));
4228 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4229 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4230 }
4232 }
4233
4234 if (flagLEP2[WeakBox]) {
4235 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
4236 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4237 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4238 }
4239 double sigma_box = average;
4240 SMresult_cache += sigma_box;
4241 }
4242 } else if (s == 196.*196.) {
4243 if (!flagLEP2[ISR])
4245 else {
4246 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu196, &(*this), _1));
4247 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4248 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4249 }
4251 }
4252
4253 if (flagLEP2[WeakBox]) {
4254 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
4255 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4256 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4257 }
4258 double sigma_box = average;
4259 SMresult_cache += sigma_box;
4260 }
4261 } else if (s == 200.*200.) {
4262 if (!flagLEP2[ISR])
4264 else {
4265 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu200, &(*this), _1));
4266 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4267 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4268 }
4270 }
4271
4272 if (flagLEP2[WeakBox]) {
4273 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
4274 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4275 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4276 }
4277 double sigma_box = average;
4278 SMresult_cache += sigma_box;
4279 }
4280 } else if (s == 202.*202.) {
4281 if (!flagLEP2[ISR])
4283 else {
4284 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu202, &(*this), _1));
4285 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4286 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4287 }
4289 }
4290
4291 if (flagLEP2[WeakBox]) {
4292 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
4293 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4294 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4295 }
4296 double sigma_box = average;
4297 SMresult_cache += sigma_box;
4298 }
4299 } else if (s == 205.*205.) {
4300 if (!flagLEP2[ISR])
4302 else {
4303 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu205, &(*this), _1));
4304 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4305 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4306 }
4308 }
4309
4310 if (flagLEP2[WeakBox]) {
4311 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
4312 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4313 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4314 }
4315 double sigma_box = average;
4316 SMresult_cache += sigma_box;
4317 }
4318 } else if (s == 207.*207.) {
4319 if (!flagLEP2[ISR])
4321 else {
4322 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu207, &(*this), _1));
4323 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4324 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4325 }
4327 }
4328
4329 if (flagLEP2[WeakBox]) {
4330 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
4331 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4332 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4333 }
4334 double sigma_box = average;
4335 SMresult_cache += sigma_box;
4336 }
4337 } else {
4338 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBmu!");
4339 }
4340
4341 double sigma_mu = SMresult_cache;
4342
4343 gsl_set_error_handler(old_handler);
4344
4345 return sigma_mu;
4346
4347 }
4348}
double LEP2sigmaMuApprox(const double s) const
The cross section at LEP2.
const double getIntegrand_sigmaWithISR_mu207(double x) const
const double getIntegrand_sigmaWithISR_mu172(double x) const
const double getIntegrand_sigmaWithISR_mu136(double x) const
const double getIntegrand_sigmaWithISR_mu161(double x) const
const double sigma_NoISR_l(const QCD::lepton l_flavor, const double s) const
const double getIntegrand_sigmaWithISR_mu130(double x) const
const double getIntegrand_sigmaWithISR_mu202(double x) const
const double getIntegrand_sigmaWithISR_mu205(double x) const
const double getIntegrand_sigmaWithISR_mu189(double x) const
const double getIntegrand_sigmaWithISR_mu196(double x) const
const double getIntegrand_sigmaWithISR_mu200(double x) const
const double getIntegrand_sigmaWithISR_mu183(double x) const
const double getIntegrand_sigmaWithISR_mu192(double x) const

◆ LEP2sigmaTau()

const double StandardModel::LEP2sigmaTau ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 4351 of file StandardModel/src/StandardModel.cpp.

4352{
4353
4354 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4355 double relerr = 1.e-7;
4356 double abserr = 1.e-17;
4357
4358 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4360
4361 /* SM contribution with the approximate formula */
4363
4364 } else {
4365
4366 if(s == 130.*130.){
4367
4368 if (!flagLEP2[ISR]){
4370 } else {
4371 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau130, &(*this), _1));
4372 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4373 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4374 }
4376 }
4377
4378 if (flagLEP2[WeakBox]) {
4379 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
4380 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4381 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4382 }
4383 double sigma_box = average;
4384 SMresult_cache += sigma_box;
4385 }
4386 } else if (s == 136.*136.) {
4387 if (!flagLEP2[ISR]){
4389 } else {
4390 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau136, &(*this), _1));
4391 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4392 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4393 }
4395 }
4396
4397 if (flagLEP2[WeakBox]) {
4398 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
4399 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4400 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4401 }
4402 double sigma_box = average;
4403 SMresult_cache += sigma_box;
4404 }
4405 } else if (s == 161.*161.){
4406 if (!flagLEP2[ISR])
4408 else {
4409 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau161, &(*this), _1));
4410 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4411 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4412 }
4414 }
4415
4416 if (flagLEP2[WeakBox]) {
4417 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
4418 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4419 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4420 }
4421 double sigma_box = average;
4422 SMresult_cache += sigma_box;
4423 }
4424 } else if (s == 172.*172.) {
4425 if (!flagLEP2[ISR])
4427 else {
4428 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau172, &(*this), _1));
4429 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4430 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4431 }
4433 }
4434
4435 if (flagLEP2[WeakBox]) {
4436 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
4437 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4438 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4439 }
4440 double sigma_box = average;
4441 SMresult_cache += sigma_box;
4442 }
4443 } else if (s == 183.*183.) {
4444 if (!flagLEP2[ISR])
4446 else {
4447 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau183, &(*this), _1));
4448 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4449 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4450 }
4452 }
4453
4454 if (flagLEP2[WeakBox]) {
4455 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
4456 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4457 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4458 }
4459 double sigma_box = average;
4460 SMresult_cache += sigma_box;
4461 }
4462 } else if (s == 189.*189.) {
4463 if (!flagLEP2[ISR])
4465 else {
4466 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau189, &(*this), _1));
4467 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4468 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4469 }
4471 }
4472
4473 if (flagLEP2[WeakBox]) {
4474 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
4475 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4476 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4477 }
4478 double sigma_box = average;
4479 SMresult_cache += sigma_box;
4480 }
4481 } else if (s == 192.*192.) {
4482 if (!flagLEP2[ISR])
4484 else {
4485 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau192, &(*this), _1));
4486 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4487 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4488 }
4490 }
4491
4492 if (flagLEP2[WeakBox]) {
4493 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
4494 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4495 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4496 }
4497 double sigma_box = average;
4498 SMresult_cache += sigma_box;
4499 }
4500 } else if (s == 196.*196.) {
4501 if (!flagLEP2[ISR])
4503 else {
4504 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau196, &(*this), _1));
4505 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4506 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4507 }
4509 }
4510
4511 if (flagLEP2[WeakBox]) {
4512 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
4513 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4514 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4515 }
4516 double sigma_box = average;
4517 SMresult_cache += sigma_box;
4518 }
4519 } else if (s == 200.*200.) {
4520 if (!flagLEP2[ISR])
4522 else {
4523 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau200, &(*this), _1));
4524 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4525 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4526 }
4528 }
4529
4530 if (flagLEP2[WeakBox]) {
4531 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
4532 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4533 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4534 }
4535 double sigma_box = average;
4536 SMresult_cache += sigma_box;
4537 }
4538 } else if (s == 202.*202.) {
4539 if (!flagLEP2[ISR])
4541 else {
4542 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau202, &(*this), _1));
4543 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4544 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4545 }
4547 }
4548
4549 if (flagLEP2[WeakBox]) {
4550 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
4551 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4552 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4553 }
4554 double sigma_box = average;
4555 SMresult_cache += sigma_box;
4556 }
4557 } else if (s == 205.*205.) {
4558 if (!flagLEP2[ISR])
4560 else {
4561 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau205, &(*this), _1));
4562 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4563 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4564 }
4566 }
4567
4568 if (flagLEP2[WeakBox]) {
4569 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
4570 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4571 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4572 }
4573 double sigma_box = average;
4574 SMresult_cache += sigma_box;
4575 }
4576 } else if (s == 207.*207.) {
4577 if (!flagLEP2[ISR])
4579 else {
4580 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau207, &(*this), _1));
4581 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4582 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4583 }
4585 }
4586
4587 if (flagLEP2[WeakBox]) {
4588 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
4589 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4590 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4591 }
4592 double sigma_box = average;
4593 SMresult_cache += sigma_box;
4594 }
4595 } else {
4596 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaTau!");
4597 }
4598
4599 double sigma_tau = SMresult_cache;
4600
4601 gsl_set_error_handler(old_handler);
4602
4603 return sigma_tau;
4604
4605 }
4606}
double LEP2sigmaTauApprox(const double s) const
The cross section at LEP2.
const double getIntegrand_sigmaWithISR_tau207(double x) const
const double getIntegrand_sigmaWithISR_tau205(double x) const
const double getIntegrand_sigmaWithISR_tau196(double x) const
const double getIntegrand_sigmaWithISR_tau161(double x) const
const double getIntegrand_sigmaWithISR_tau183(double x) const
const double getIntegrand_sigmaWithISR_tau130(double x) const
const double getIntegrand_sigmaWithISR_tau200(double x) const
const double getIntegrand_sigmaWithISR_tau189(double x) const
const double getIntegrand_sigmaWithISR_tau192(double x) const
const double getIntegrand_sigmaWithISR_tau136(double x) const
const double getIntegrand_sigmaWithISR_tau202(double x) const
const double getIntegrand_sigmaWithISR_tau172(double x) const

◆ m_q()

double StandardModel::m_q ( const QCD::quark  q,
const double  mu,
const orders  order = FULLNLO 
) const
inlineprotected

Definition at line 3565 of file StandardModel.h.

3566 {
3567 switch(q) {
3568 case QCD::UP:
3569 case QCD::DOWN:
3570 case QCD::STRANGE:
3571 return Mrun(mu, getQuarks(q).getMass_scale(),
3572 getQuarks(q).getMass(), q, order);
3573 case QCD::CHARM:
3574 case QCD::BOTTOM:
3575 case QCD::TOP:
3576 return Mrun(mu, getQuarks(q).getMass(), q, order);
3577 default:
3578 throw std::runtime_error("Error in StandardModel::m_q()");
3579 }
3580 }

◆ MLL2eeff()

const double StandardModel::MLL2eeff ( const Particle  f,
const double  s,
const double  t 
) const

Definition at line 3812 of file StandardModel/src/StandardModel.cpp.

3812 {
3813
3814 // Definitions
3815 double Qf, geLSM, gfLSM, is2c2, GZ, Mz2s;
3816
3817 double MLL2SM;
3818
3819 // -------------------------------------------
3820
3821 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3822
3823 is2c2 = 1. / s02() / c02();
3824
3825 GZ = Gamma_Z();
3826
3827 Mz2s = Mz * Mz - s;
3828
3829 if (f.is("ELECTRON")) {
3830 Qf = leptons[ELECTRON].getCharge();
3831 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3832 } else if (f.is("MU")) {
3833 Qf = leptons[MU].getCharge();
3834 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3835 } else if (f.is("TAU")) {
3836 Qf = leptons[TAU].getCharge();
3837 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3838 } else if (f.is("UP")) {
3839 Qf = quarks[UP].getCharge();
3840 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3841 } else if (f.is("CHARM")) {
3842 Qf = quarks[CHARM].getCharge();
3843 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3844 } else if (f.is("DOWN")) {
3845 Qf = quarks[DOWN].getCharge();
3846 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3847 } else if (f.is("STRANGE")) {
3848 Qf = quarks[STRANGE].getCharge();
3849 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3850 } else if (f.is("BOTTOM")) {
3851 Qf = quarks[BOTTOM].getCharge();
3852 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3853 } else
3854 throw std::runtime_error("StandardModel::MLL2eeff: wrong argument");
3855
3856 // LL SM squared amplitude
3857 MLL2SM = Qf * Qf
3858 + (is2c2 * is2c2 * (geLSM * geLSM * gfLSM * gfLSM) * s * s
3859 + 2.0 * Qf * is2c2 * (geLSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3860
3861 return MLL2SM;
3862
3863}

◆ MLR2eeff()

const double StandardModel::MLR2eeff ( const Particle  f,
const double  s 
) const

Definition at line 3709 of file StandardModel/src/StandardModel.cpp.

3709 {
3710
3711 // Definitions
3712 double Qf, geLSM, gfRSM, is2c2, GZ, Mz2s;
3713
3714 double MLR2SM;
3715
3716 // -------------------------------------------
3717
3718 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3719
3720 is2c2 = 1. / s02() / c02();
3721
3722 GZ = Gamma_Z();
3723
3724 Mz2s = Mz * Mz - s;
3725
3726 if (f.is("ELECTRON")) {
3727 Qf = leptons[ELECTRON].getCharge();
3728 gfRSM = - Qf * s02();
3729 } else if (f.is("MU")) {
3730 Qf = leptons[MU].getCharge();
3731 gfRSM = - Qf * s02();
3732 } else if (f.is("TAU")) {
3733 Qf = leptons[TAU].getCharge();
3734 gfRSM = - Qf * s02();
3735 } else if (f.is("UP")) {
3736 Qf = quarks[UP].getCharge();
3737 gfRSM = - Qf * s02();
3738 } else if (f.is("CHARM")) {
3739 Qf = quarks[CHARM].getCharge();
3740 gfRSM = - Qf * s02();
3741 } else if (f.is("DOWN")) {
3742 Qf = quarks[DOWN].getCharge();
3743 gfRSM = - Qf * s02();
3744 } else if (f.is("STRANGE")) {
3745 Qf = quarks[STRANGE].getCharge();
3746 gfRSM = - Qf * s02();
3747 } else if (f.is("BOTTOM")) {
3748 Qf = quarks[BOTTOM].getCharge();
3749 gfRSM = - Qf * s02();
3750 } else
3751 throw std::runtime_error("StandardModel::MLR2eeff: wrong argument");
3752
3753 // LR, RL, LL and RR SM squared amplitudes
3754 MLR2SM = Qf * Qf
3755 + (is2c2 * is2c2 * (geLSM * geLSM * gfRSM * gfRSM) * s * s
3756 + 2.0 * Qf * is2c2 * (geLSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3757
3758 return MLR2SM;
3759}

◆ MRL2eeff()

const double StandardModel::MRL2eeff ( const Particle  f,
const double  s 
) const

Definition at line 3760 of file StandardModel/src/StandardModel.cpp.

3760 {
3761
3762 // Definitions
3763 double Qf, geRSM, gfLSM, is2c2, GZ, Mz2s;
3764
3765 double MRL2SM;
3766
3767 // -------------------------------------------
3768
3769 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3770
3771 is2c2 = 1. / s02() / c02();
3772
3773 GZ = Gamma_Z();
3774
3775 Mz2s = Mz * Mz - s;
3776
3777 if (f.is("ELECTRON")) {
3778 Qf = leptons[ELECTRON].getCharge();
3779 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3780 } else if (f.is("MU")) {
3781 Qf = leptons[MU].getCharge();
3782 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3783 } else if (f.is("TAU")) {
3784 Qf = leptons[TAU].getCharge();
3785 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3786 } else if (f.is("UP")) {
3787 Qf = quarks[UP].getCharge();
3788 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3789 } else if (f.is("CHARM")) {
3790 Qf = quarks[CHARM].getCharge();
3791 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3792 } else if (f.is("DOWN")) {
3793 Qf = quarks[DOWN].getCharge();
3794 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3795 } else if (f.is("STRANGE")) {
3796 Qf = quarks[STRANGE].getCharge();
3797 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3798 } else if (f.is("BOTTOM")) {
3799 Qf = quarks[BOTTOM].getCharge();
3800 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3801 } else
3802 throw std::runtime_error("StandardModel::MRL2eeff: wrong argument");
3803
3804 // RL SM squared amplitude
3805 MRL2SM = Qf * Qf
3806 + (is2c2 * is2c2 * (geRSM * geRSM * gfLSM * gfLSM) * s * s
3807 + 2.0 * Qf * is2c2 * (geRSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3808
3809 return MRL2SM;
3810}

◆ MRR2eeff()

const double StandardModel::MRR2eeff ( const Particle  f,
const double  s,
const double  t 
) const

Definition at line 3864 of file StandardModel/src/StandardModel.cpp.

3864 {
3865
3866 // Definitions
3867 double Qf, geRSM, gfRSM, is2c2, GZ, Mz2s;
3868
3869 double MRR2SM;
3870
3871 // -------------------------------------------
3872
3873 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3874
3875 is2c2 = 1. / s02() / c02();
3876
3877 GZ = Gamma_Z();
3878
3879 Mz2s = Mz * Mz - s;
3880
3881 if (f.is("ELECTRON")) {
3882 Qf = leptons[ELECTRON].getCharge();
3883 gfRSM = - Qf * s02();
3884 } else if (f.is("MU")) {
3885 Qf = leptons[MU].getCharge();
3886 gfRSM = - Qf * s02();
3887 } else if (f.is("TAU")) {
3888 Qf = leptons[TAU].getCharge();
3889 gfRSM = - Qf * s02();
3890 } else if (f.is("UP")) {
3891 Qf = quarks[UP].getCharge();
3892 gfRSM = - Qf * s02();
3893 } else if (f.is("CHARM")) {
3894 Qf = quarks[CHARM].getCharge();
3895 gfRSM = - Qf * s02();
3896 } else if (f.is("DOWN")) {
3897 Qf = quarks[DOWN].getCharge();
3898 gfRSM = - Qf * s02();
3899 } else if (f.is("STRANGE")) {
3900 Qf = quarks[STRANGE].getCharge();
3901 gfRSM = - Qf * s02();
3902 } else if (f.is("BOTTOM")) {
3903 Qf = quarks[BOTTOM].getCharge();
3904 gfRSM = - Qf * s02();
3905 } else
3906 throw std::runtime_error("StandardModel::MRR2eeff: wrong argument");
3907
3908 // RR SM squared amplitude
3909 MRR2SM = Qf * Qf
3910 + (is2c2 * is2c2 * (geRSM * geRSM * gfRSM * gfRSM) * s * s
3911 + 2.0 * Qf * is2c2 * (geRSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3912
3913 return MRR2SM;
3914}

◆ Mw()

const double StandardModel::Mw ( ) const
virtual

The SM prediction for the \(W\)-boson mass in the on-shell scheme, \(M_{W,\mathrm{SM}}\).

When the model flag Mw of StandardModel is set to APPROXIMATEFORMULA, the current function uses the two-loop approximate formula in EWSMApproximateFormulae::Mw(), which includes the full two-loop EW contribution of \({\cal O}(\alpha^2)\) as well as the leading \({\cal O}(G_\mu^2\alpha_s m_t^4)\) and \({\cal O}(G_\mu^3m_t^6)\) contributions.

When the model flag Mw is not set to APPROXIMATEFORMULA, the \(W\)-boson mass is computed from \(\Delta r(M_W)\) with an iterative procedure. The target accuracy of the iterative calculation is specified with the constant Mw_error. This function calls resumMw(), in which \(M_W\) is computed with a given \(\Delta r\), equivalently with \(\Delta\rho\) and \(\Delta r_{\mathrm{rem}}\)

Returns
\(M_{W,\mathrm{SM}}\) in GeV
See also
resumMw()
Attention
If the model flag CacheInStandardModel of StandardModel is set to true, the caching method implemented in the current class is employed.

Reimplemented in GeorgiMachacek, NPbase, NPEpsilons, NPEpsilons_pureNP, NPSMEFTd6, NPSMEFTd6General, NPZbbbar, SUSY, and THDMW.

Definition at line 1025 of file StandardModel/src/StandardModel.cpp.

1026{
1027 /* Debug */
1028 //std::cout << std::boolalpha
1029 // << checkScheme(schemeMw_cache,schemeMw,false)
1030 // << " [cache:" << schemeMw_cache
1031 // << " current:" << schemeMw << "]" << std::endl;
1032
1033 if (FlagMWinput)
1034 return Mw_inp;
1035
1037 if (useMw_cache)
1038 return Mw_cache;
1039
1040 double Mw;
1041 if (FlagMw.compare("APPROXIMATEFORMULA") == 0)
1043 else {
1044 //std::cout << std::setprecision(12)
1045 // << "TEST: Mw_tree = " << Mw_tree() << std::endl;
1046
1047 double DeltaRho[orders_EW_size], DeltaR_rem[orders_EW_size];
1048 ComputeDeltaRho(Mw_tree(), DeltaRho);
1049 ComputeDeltaR_rem(Mw_tree(), DeltaR_rem);
1050 Mw = resumMw(Mw_tree(), DeltaRho, DeltaR_rem);
1051
1052 /* Mw from iterations */
1053 double Mw_org = Mw_tree();
1054 while (fabs(Mw - Mw_org) > Mw_error) {
1055 Mw_org = Mw;
1056 ComputeDeltaRho(Mw, DeltaRho);
1057 ComputeDeltaR_rem(Mw, DeltaR_rem);
1058 Mw = resumMw(Mw, DeltaRho, DeltaR_rem);
1059 /* TEST */
1060 //int prec_def = std::cout.precision();
1061 //std::cout << std::setprecision(12) << "TEST: Mw_org = " << Mw_org
1062 // << " Mw_new = " << Mw << std::endl;
1063 //std::cout.precision(prec_def);
1064 }
1065 }
1066
1067// Mw = 80.426; // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
1068// Mw = 80.379; // FOR HEFFDF1 TEST: VALUE IN 2007.04191
1069 Mw_cache = Mw;
1070 useMw_cache = true;
1071 return Mw;
1072}
double Mw() const
The -boson mass with the full two-loop EW corrections.
static const double Mw_error
The target accuracy of the iterative calculation of the -boson mass in units of GeV.
void ComputeDeltaR_rem(const double Mw_i, double DeltaR_rem[orders_EW_size]) const
A method to collect computed via subclasses.
const double Mw_tree() const
The tree-level mass of the boson, .
double resumMw(const double Mw_i, const double DeltaRho[orders_EW_size], const double DeltaR_rem[orders_EW_size]) const
A method to compute the -boson mass from and .

◆ Mw_tree()

const double StandardModel::Mw_tree ( ) const

The tree-level mass of the \(W\) boson, \(M_W^{\mathrm{tree}}\).

Returns
\(M_W^{\mathrm{tree}}\) in GeV.

Definition at line 1003 of file StandardModel/src/StandardModel.cpp.

1004{
1005 if (FlagMWinput){
1006 return Mw_inp;
1007 } else
1008 return ( Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz)));
1009}

◆ MwbarFromMw()

const double StandardModel::MwbarFromMw ( const double  Mw) const

A method to convert the \(W\)-boson mass in the experimental/running-width scheme to that in the complex-pole/fixed-width scheme.

The mass parameter \(\overline{M}_W\) in the complex-pole/fixed-width scheme [Bardin:1988xt] is given by

\[ \overline{M}_{W} = M_{W} - \frac{\Gamma_{W}^2}{2M_{W}}\,, \]

where \(M_W\) and \(\Gamma_{W}\) are the mass and width of the \(W\) boson in the experimental/running-width scheme:

\[ \Gamma_W = \frac{3G_\mu M_W^3}{2\sqrt{2}\pi} \left( 1 + \frac{2\alpha_s(M_W^2)}{3\pi} \right)\,. \]

Parameters
[in]Mwthe \(W\)-boson mass in the experimental/running-width scheme
Returns
\(\overline{M}_W\) in GeV

Definition at line 1210 of file StandardModel/src/StandardModel.cpp.

1211{
1212 double AlsMw = Als(Mw, FULLNLO);
1213 double Gw_SM = 3.0 * GF * pow(Mw, 3.0) / 2.0 / sqrt(2.0) / M_PI
1214 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1215
1216 return ( Mw - Gw_SM * Gw_SM / 2.0 / Mw);
1217}

◆ MwFromMwbar()

const double StandardModel::MwFromMwbar ( const double  Mwbar) const

A method to convert the \(W\)-boson mass in the complex-pole/fixed-width scheme to that in the experimental/running-width scheme.

The experimental mass \(M_W\) is derived

\[ M_W = \overline{M}_W + \frac{\Gamma_{W}^2}{2\overline{M}_{W}}\,, \]

where \(\overline{M}_W\) is the mass parameter in the complex-pole/fixed-width scheme [Bardin:1988xt], and \(\Gamma_{W}\) is the \(W\)-boson width in the experimental/running-width scheme:

\[ \Gamma_W = \frac{3G_\mu M_W^3}{2\sqrt{2}\pi} \left( 1 + \frac{2\alpha_s(M_W^2)}{3\pi} \right) \approx \frac{3G_\mu \overline{M}_W^3}{2\sqrt{2}\pi} \left( 1 + \frac{2\alpha_s(\overline{M}_W^2)}{3\pi} \right)\,. \]

Parameters
[in]Mwbarthe \(W\)-boson mass in the complex-pole/fixed-width scheme
Returns
\(M_W\) in GeV

Definition at line 1219 of file StandardModel/src/StandardModel.cpp.

1220{
1221 double AlsMw = Als(Mwbar, FULLNNLO);
1222 double Gw_SM = 3.0 * GF * pow(Mwbar, 3.0) / 2.0 / sqrt(2.0) / M_PI
1223 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1224
1225 return (Mwbar + Gw_SM * Gw_SM / 2.0 / Mwbar);
1226}

◆ Mzbar()

double StandardModel::Mzbar ( ) const

The \(Z\)-boson mass \(\overline{M}_Z\) in the complex-pole/fixed-width scheme.

The mass parameter \(\overline{M}_Z\) in the complex-pole/fixed-width scheme [Bardin:1988xt] is given by

\[ \overline{M}_{Z} = M_{Z} - \frac{\Gamma_{Z}^2}{2M_{Z}}\,, \]

where \(M_Z\) and \(\Gamma_{Z}\) are the mass and width of the \(Z\) boson in the experimental/running-width scheme:

\begin{align} \Gamma(Z\to f\bar{f}) = \frac{G_\mu M_Z^3}{24\sqrt{2}\pi} \left[ \left( \frac{v_f}{a_f} \right)^2 + 1 \right] \times \left\{ \begin{array}{ll} 1 & \mathrm{for}\quad f=\ell\,, \\[2mm] \displaystyle N_c \left( 1 + \frac{\alpha_s(M_Z^2)}{\pi} \right) & \mathrm{for}\quad f=q \end{array} \right. \end{align}

with \(v_f/a_f=1-4|Q_f|s_{W,\mathrm{tree}}^2\).

Returns
\(\overline{M}_Z\) in GeV

Definition at line 1193 of file StandardModel/src/StandardModel.cpp.

1194{
1195 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1196 double sW2tree = 1.0 - Mw_tree() * Mw_tree() / Mz / Mz;
1197 double Gz = 6.0 * G0; // neutrinos
1198 Gz += 3.0 * G0 * (pow(1.0 - 4.0 * sW2tree, 2.0) + 1.0); // e, mu and tau
1199 Gz += 6.0 * G0 * (pow(1.0 - 8.0 / 3.0 * sW2tree, 2.0) + 1.0)
1200 * (1.0 + AlsMz / M_PI); // u and c
1201 Gz += 9.0 * G0 * (pow(1.0 - 4.0 / 3.0 * sW2tree, 2.0) + 1.0)
1202 * (1.0 + AlsMz / M_PI); // d, s and b
1203
1204 //Gz = 2.4952; // experimental data
1205 //std::cout << "Gz=" << Gz << std::endl; // for test
1206
1207 return ( Mz - Gz * Gz / 2.0 / Mz);
1208}

◆ N_nu()

const double StandardModel::N_nu ( ) const
virtual

The number of neutrinos obtained indirectly from the measurements at the Z pole, \(N_{\nu}\).

\(N_{\nu}\) is calculated with

\[ N_{\nu} = \frac{\Gamma_\ell}{\Gamma_{\nu}}\left(\sqrt{\frac{12\pi R_\ell}{M_Z^2 \sigma_\mathrm{had}^0}}-R_\ell - 3\right)\,. \]

Returns
\(N_{\nu} \)

Reimplemented in NPbase.

Definition at line 1562 of file StandardModel/src/StandardModel.cpp.

1563{
1564 double Nnu = 0.0;
1565 double Gl = 0.0;
1566 double Rl = 0.0;
1567
1568 // Don't assume lepton universality: average over lepton flavours
1570 Rl = (1.0/3.0) * ( R0_f(leptons[ELECTRON]) + R0_f(leptons[MU]) + R0_f(leptons[TAU]) );
1571
1572 Nnu = sqrt( 12.0 * M_PI * Rl / Mz / Mz / sigma0_had() ) - Rl -3.0;
1573
1574 Nnu = (Gl/Gamma_inv()) * Nnu;
1575
1576 return Nnu;
1577
1578}
virtual const double sigma0_had() const
The hadronic cross section for at the -pole, .
virtual const double R0_f(const Particle f) const
The ratio .

◆ PostUpdate()

bool StandardModel::PostUpdate ( )
virtual

The post-update method for StandardModel.

This method runs all the procedures that are need to be executed after the model is successfully updated. This includes

  • computing the updated CKM and PMNS matrices
  • computing the Yukawa matrices
  • updating the Standard Model parameters in the StandardModelMatching class.
    Returns
    a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, HiggsChiral, HiggsKigen, NPd6SILH, NPEpsilons, NPSMEFTd6, NPSMEFTd6General, NPSMEFTd6U2, NPSMEFTd6U2qU1le, NPSMEFTd6U3, NPZbbbar, NPZbbbarLinearized, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 243 of file StandardModel/src/StandardModel.cpp.

244{
245 if (!QCD::PostUpdate()) return (false);
246
247 SMSuccess = true;
248 /* Set the CKM and PMNS matrices if not already set in the derived classes */
249 if(requireCKM)
250 computeCKM();
251
252 /* Compute the 5-quark contribution to the running of alpha*/
253 dAl5hMz = Dalpha5hMz();
254
255 /* Set the Yukawa matrices */
256 if (!isModelSUSY()) {
258 }
259
260 /* Check whether the parameters for the EWPO are updated or not */
261 if (!checkSMparamsForEWPO()) {
263 useDeltaAlpha_cache = false;
264 useMw_cache = false;
265 useGammaW_cache = false;
266 for (int i = 0; i < 12; ++i) {
267 useRhoZ_f_cache[i] = false;
268 useKappaZ_f_cache[i] = false;
269 }
270 }
272 /* Necessary for updating StandardModel parameters in StandardModelMatching */
273 if (!isModelSUSY()) SMM.getObj().updateSMParameters();
274
275 iterationNo++;
276
277 return (true);
278}
void setSMupdated() const
a member used for the caching for .
Definition: Flavour.cpp:373
bool isModelSUSY() const
Definition: Model.h:182
virtual bool PostUpdate()
The post-update method for QCD.
Definition: QCD.cpp:158
virtual void computeCKM()
The method to compute the CKM matrix.
virtual void computeYukawas()
The method to compute the Yukawas matrix.
virtual const double Dalpha5hMz() const
The 5-quark contribution to the running of the em constant to the pole. .
bool checkSMparamsForEWPO()
A method to check whether the parameters relevant to the EWPO are updated.

◆ PreUpdate()

bool StandardModel::PreUpdate ( )
virtual

The pre-update method for StandardModel.

This method initializes the internal flags requireCKM, requireYe and requireYn, and calls QCD::PreUpdate(), before updating the model parameters with the method Update().

Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPSMEFTd6General, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 216 of file StandardModel/src/StandardModel.cpp.

217{
218 requireCKM = false;
219 requireYe = false;
220 requireYn = false;
221
222 if (!QCD::PreUpdate()) return (false);
223
224 return (true);
225}
virtual bool PreUpdate()
The pre-update method for QCD.
Definition: QCD.cpp:130

◆ Qwemoller()

const double StandardModel::Qwemoller ( const double  q2,
const double  y 
) const
virtual

The computation of the electron's weak charge.

Parameters
[in]q2the \(Q^2\) at which the weak charge is measured
[in]y
Returns
\(Q_{w}(e)\)

Reimplemented in NPbase.

Definition at line 2671 of file StandardModel/src/StandardModel.cpp.

2672{
2673 // Weak charge
2674 double Qwe;
2675
2676 // definitions
2677 double MwSM,f1,fy,f2,af2;
2678 const double mpion=134.9766e-3;
2679
2680 // -----------------------------------------------------------------
2681
2682 double dalfos, dalfms, alfams;
2683 double rhoNC, kappa0, s2MSbar,c2MSbar;
2684 double xi;
2685 double leptk0,quarkk0;
2686 double elm=leptons[ELECTRON].getMass(), mum=leptons[MU].getMass(), taum=leptons[TAU].getMass();
2687
2688 // -----------------------------------------------------------------
2689
2690 // w mass
2691 MwSM=Mw();
2692
2693 // xi factor
2694 xi=mHl*mHl/Mz/Mz;
2695
2696 // -----------------------------------------------------------------
2697
2698 // universal corrections
2699 // ---------------------
2700
2701 // obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2702 // -----------------------------------------------
2703
2704 // on-shell value of delta alpha(mz)
2705 dalfos=1.0-ale/alphaMz();
2706 // msbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2707 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2708 // msbar value of alfa(mz)
2709 alfams=ale/(1.0-dalfms);
2710
2711 // ms bar weinberg's angle from the effective leptonic angle
2712 // (formula from PDG, Erler & Langacker ew review)
2713 // ---------------------------------------------------------
2714 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2715 c2MSbar=1.0-s2MSbar;
2716
2717 // rho parameter (expansion in alfams)
2718 // -------------
2719
2720 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2721
2722 // kappa at zero momentum (expansion in alfa)
2723 // ----------------------
2724
2725 // lepton contribution to kappa0
2726 leptk0=((-0.5)*(-1)-2.0*s2MSbar)*2.0*(log(elm/Mz)+log(mum/Mz)+log(taum/Mz))/3.0;
2727
2728 // quark contribution to kappa0 (updated from hep-ph/0302149)
2729 quarkk0=-6.802;
2730
2731 kappa0=1.0-ale/(2.0*M_PI*s2MSbar)*(leptk0+quarkk0-(7.0*c2MSbar/2.0+1.0/12.0)*log(c2MSbar)+(7.0/9.0-s2MSbar/3.0));
2732
2733 // -----------------------------------------------------------------
2734
2735 // f1(y,q2) (expansion in alfa)
2736 // --------
2737
2738 // f(y)
2739 fy=-2.0*log(y*(1.0-y))/3.0+1.0/pow((1.0-y+y*y),2)*(-2.0*(1.0-y)*(3.0-3.0*y+4.0*y*y*y- 3.0*y*y*y*y)*log(1.0-y)-2.0*y*(1.0+3.0*y-6.0*y*y+8.0*y*y*y-3.0*y*y*y*y)*log(y)+ (1.0-y)*(2.0-2.0*y-7.0*y*y+10.0*y*y*y-8.0*y*y*y*y+3.0*y*y*y*y*y)*log(1.0-y)*log(1.0-y)- y*(2.0-3.0*y-5.0*y*y+8.0*y*y*y-7.0*y*y*y*y+3.0*y*y*y*y*y)*log(y)*log(y)+ (2.0-4.0*y+11.0*y*y*y-13.0*y*y*y*y+9.0*y*y*y*y*y-3.0*y*y*y*y*y*y)*(M_PI*M_PI-2.0*log(1.0-y)*log(y)));
2740
2741 f1=-ale/(4.0*M_PI)*(1.0-4.0*kappa0*s2MSbar)*(22.0*log(y*Mz*Mz/q2)/3.0+85.0/9.0+fy);
2742
2743 // note that i have used 1-4*kappa*s2MSbar instead of 1-4*s2MSbar or an average as suggested in the
2744 // reference
2745
2746
2747 // f2(y,q2) (expansion in alfa)
2748 // --------
2749 // (y=1/2 approximattion using a pion loop calculation)
2750
2751 // af2
2752 af2=sqrt(1.0+4.0*mpion*mpion/q2);
2753 f2=ale/(4.0*M_PI)*(af2*af2*af2/3.0*log((af2+1.0)/(af2-1.0))-2.0/9.0-2.0*af2*af2/3.0);
2754
2755
2756 // electron's weak charge
2757 // ----------------------
2758 Qwe=-rhoNC*(1.0-4.0*kappa0*s2MSbar+alfams/(4.0*M_PI*s2MSbar)+f1+f2- 3.0*alfams*(1.0-4.0*kappa0*s2MSbar)*(1.0+(1.0-4.0*kappa0*s2MSbar)*(1.0-4.0*kappa0*s2MSbar))/(32.0*M_PI*s2MSbar*c2MSbar));
2759
2760 // again, i have used 1-4*kappa*s2MSbar even in the loop contributions
2761
2762 return Qwe;
2763}
A class for , relevant for mesons mixing in the Standard Model.
Definition: xi.h:23

◆ Qwn()

const double StandardModel::Qwn ( ) const
virtual

The computation of the neutron weak charge: Qwn.

Follows J.Erler,A.Kurylov,M.J.Ramsey-Musolf hep-ph/0302149.

Returns
\(Q_{W}(n)\)

Reimplemented in NPbase.

Definition at line 2895 of file StandardModel/src/StandardModel.cpp.

2896{
2897 // Definitions
2898 double qwneutron;
2899
2900 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxnww,boxnzz,boxnaz;
2901 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2902 const double lambda=775.49e-3;
2903 const double caz=1.5;
2904
2905 // lepton masses
2906 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2907
2908 // -----------------------------------------------------------------
2909 double dalfos, dalfms, alfams;
2910 double rhoNC, s2MSbar,c2MSbar;
2911 double xi;
2912 double elm=leptons[ELECTRON].getMass();
2913 // -----------------------------------------------------------------
2914
2915 // W mass
2916 MwSM=Mw();
2917
2918 // xi factor
2919 xi=mHl*mHl/Mz/Mz;
2920
2921 // alfa/pi
2922 alfapi=ale/M_PI;
2923
2924 // alfa_s(Mw)
2925 asMw = Als(MwSM, FULLNLO);
2926
2927 // -----------------------------------------------------------------
2928
2929 // Universal corrections
2930 // ---------------------
2931
2932 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2933 // -----------------------------------------------
2934
2935 // on-shell value of delta alpha(mz)
2936 dalfos=1.0-ale/alphaMz();
2937 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2938 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2939 // MSbar value of alfa(mz)
2940 alfams=ale/(1.0-dalfms);
2941
2942 // MS bar weinberg's angle from the effective leptonic angle
2943 // (formula from PDG, Erler & Langacker ew review)
2944 // ---------------------------------------------------------
2945 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2946 c2MSbar=1.0-s2MSbar;
2947
2948 // rho parameter (expansion in alfams)
2949 // -------------
2950
2951 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2952
2953 // -----------------------------------------------------------------
2954
2955 // sin2w_ms(0) eq.14
2956 // -----------------
2957
2958 // hadronic contribution
2959 dkappa5h=7.9e-3;
2960
2961 s2MSbar0=0.0;
2962
2963 for (int i = 0; i < 3; ++i) {
2964 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2965 }
2966
2967 s2MSbar0=s2MSbar+dkappa5h+alfapi*((s2MSbar0*(1.0+0.75*alfapi)+135.0*alfapi/32.0)*(1.0-4.0*s2MSbar)/12.0- (7.0*c2MSbar/4.0+1.0/24.0)*2.0*log(Mz/MwSM)+s2MSbar/6.0-7.0/18.0);
2968
2969 // -----------------------------------------------------------------
2970
2971 // external leg corrections
2972
2973 deltae=-0.5*alfapi;
2974
2975 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2976
2977 // -----------------------------------------------------------------
2978
2979 // boxes
2980 // -----
2981
2982 boxnww=alfams*(-2.0+4.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2983
2984 // pure zz and az boxes from prd 17 3055 app.a
2985
2986 boxnzz=alfams*(9.0/4.0-13.0*s2MSbar+34.0*s2MSbar*s2MSbar-32.0*s2MSbar*s2MSbar*s2MSbar)*(1.0-AlsMz/M_PI)/(4.0*M_PI*s2MSbar*c2MSbar);
2987
2988 // i assumme the same caz as in the proton enters for the neutron
2989 boxnaz=alfams*(4.0-16.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2990
2991 // -----------------------------------------------------------------
2992
2993 // weak charges
2994 // ------------
2995
2996 qwneutron=-(rhoNC+deltae)*(1.0+deltaep)+boxnww+boxnzz+boxnaz;
2997
2998 return qwneutron;
2999
3000}
An observable class for the relative deviation from the SM of the EM coupling .

◆ Qwp()

const double StandardModel::Qwp ( ) const
virtual

The computation of the proton weak charge: Qwp.

Follows J.Erler,A.Kurylov,M.J.Ramsey-Musolf hep-ph/0302149.

Returns
\(Q_{W}(p)\)

Reimplemented in NPbase.

Definition at line 2787 of file StandardModel/src/StandardModel.cpp.

2788{
2789 // Definitions
2790 double qwproton;
2791
2792 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxpww,boxpzz,boxpaz;
2793 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2794 const double lambda=775.49e-3;
2795 const double caz=1.5;
2796
2797 // lepton masses
2798 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2799
2800 // -----------------------------------------------------------------
2801 double dalfos, dalfms, alfams;
2802 double rhoNC, s2MSbar,c2MSbar;
2803 double xi;
2804 double elm=leptons[ELECTRON].getMass();
2805 // -----------------------------------------------------------------
2806
2807 // W mass
2808 MwSM=Mw();
2809
2810 // xi factor
2811 xi=mHl*mHl/Mz/Mz;
2812
2813 // alfa/pi
2814 alfapi=ale/M_PI;
2815
2816 // alfa_s(Mw)
2817 asMw = Als(MwSM, FULLNLO);
2818
2819 // -----------------------------------------------------------------
2820
2821 // Universal corrections
2822 // ---------------------
2823
2824 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2825 // -----------------------------------------------
2826
2827 // on-shell value of delta alpha(mz)
2828 dalfos=1.0-ale/alphaMz();
2829 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2830 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2831 // MSbar value of alfa(mz)
2832 alfams=ale/(1.0-dalfms);
2833
2834 // MS bar weinberg's angle from the effective leptonic angle
2835 // (formula from PDG, Erler & Langacker ew review)
2836 // ---------------------------------------------------------
2837 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2838 c2MSbar=1.0-s2MSbar;
2839
2840 // rho parameter (expansion in alfams)
2841 // -------------
2842
2843 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2844
2845 // -----------------------------------------------------------------
2846
2847 // sin2w_ms(0) eq.14
2848 // -----------------
2849
2850 // hadronic contribution
2851 dkappa5h=7.9e-3;
2852
2853 s2MSbar0=0.0;
2854
2855 for (int i = 0; i < 3; ++i) {
2856 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2857 }
2858
2859 s2MSbar0=s2MSbar+dkappa5h+alfapi*((s2MSbar0*(1.0+0.75*alfapi)+135.0*alfapi/32.0)*(1.0-4.0*s2MSbar)/12.0- (7.0*c2MSbar/4.0+1.0/24.0)*2.0*log(Mz/MwSM)+s2MSbar/6.0-7.0/18.0);
2860
2861 // -----------------------------------------------------------------
2862
2863 // external leg corrections
2864
2865 deltae=-0.5*alfapi;
2866
2867 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2868
2869 // -----------------------------------------------------------------
2870
2871 // boxes
2872 // -----
2873
2874 boxpww=alfams*(2.0+5.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2875
2876 // pure zz and az boxes from prd 17 3055 app.a
2877
2878 boxpzz=alfams*(9.0/4.0-14.0*s2MSbar+38.0*s2MSbar*s2MSbar-40.0*s2MSbar*s2MSbar*s2MSbar)*(1.0-AlsMz/M_PI)/(4.0*M_PI*s2MSbar*c2MSbar);
2879
2880 boxpaz=5.0*alfams*(1.0-4.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2881
2882 // i assumme the same caz as in the proton enters for the neutron
2883 // -----------------------------------------------------------------
2884
2885 // weak charges
2886 // ------------
2887
2888 qwproton=(rhoNC+deltae)*(1.0-4.0*s2MSbar0+deltaep)+boxpww+boxpzz+boxpaz;
2889
2890 return qwproton;
2891
2892}

◆ R0_f()

const double StandardModel::R0_f ( const Particle  f) const
virtual

The ratio \(R_\ell^0=\Gamma(Z\to {\rm hadrons})/\Gamma(Z\to \ell^+ \ell^-)\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(R_\ell^0\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, \(R_\ell^0\) is calculated with

\[ R_\ell^0 = \frac{\Gamma_h}{\Gamma_\ell}\,. \]

, where \(\ell\) denotes a charged lepton.

Parameters
[in]fa lepton or quark
Returns
\(R_\ell^0 \)

Reimplemented in NPbase, NPSMEFTd6General, NPZbbbar, and NPEpsilons.

Definition at line 1485 of file StandardModel/src/StandardModel.cpp.

1486{
1487
1488 if (f.is("ELECTRON")) {
1490 /* SM contribution with the approximate formula */
1491 return (myApproximateFormulae->X_full("R0_electron"));
1492 else
1493 return (Gamma_had() / GammaZ(leptons[ELECTRON]));
1494 } else if (f.is("MU")) {
1496 /* SM contribution with the approximate formula */
1497 return (myApproximateFormulae->X_full("R0_muon"));
1498 else
1499 return (Gamma_had() / GammaZ(leptons[MU]));
1500 } else if (f.is("TAU")) {
1502 /* SM contribution with the approximate formula */
1503 return (myApproximateFormulae->X_full("R0_tau"));
1504 else
1505 return (Gamma_had() / GammaZ(leptons[TAU]));
1506 } else if (f.is("NEUTRINO_1")) {
1508 /* SM contribution with the approximate formula */
1509 return (myApproximateFormulae->X_full("R0_neutrino"));
1510 else
1511 return (GammaZ(leptons[NEUTRINO_1]) / Gamma_had());
1512 } else if (f.is("NEUTRINO_2")) {
1514 /* SM contribution with the approximate formula */
1515 return (myApproximateFormulae->X_full("R0_neutrino"));
1516 else
1517 return (GammaZ(leptons[NEUTRINO_2]) / Gamma_had());
1518 } else if (f.is("NEUTRINO_3")) {
1520 /* SM contribution with the approximate formula */
1521 return (myApproximateFormulae->X_full("R0_neutrino"));
1522 else
1523 return (GammaZ(leptons[NEUTRINO_3]) / Gamma_had());
1524 } else if (f.is("UP")) {
1526 /* SM contribution with the approximate formula */
1527 return (myApproximateFormulae->X_full("R0_up"));
1528 else
1529 return (GammaZ(quarks[UP]) / Gamma_had());
1530
1531 } else if (f.is("STRANGE")) {
1533 /* SM contribution with the approximate formula */
1534 return (myApproximateFormulae->X_full("R0_strange"));
1535 else
1536 return (GammaZ(quarks[STRANGE]) / Gamma_had());
1537
1538 } else if (f.is("CHARM")) {
1540 /* SM contribution with the approximate formula */
1541 return (myApproximateFormulae->X_full("R0_charm"));
1542 else
1543 return (GammaZ(quarks[CHARM]) / Gamma_had());
1544
1545 } else if (f.is("BOTTOM")) {
1547 /* SM contribution with the approximate formula */
1548 return (myApproximateFormulae->X_full("R0_bottom"));
1549 else
1550 return (GammaZ(quarks[BOTTOM]) / Gamma_had());
1551
1552 } else throw std::runtime_error("StandardModel::R0_f called with wrong argument");
1553
1554}

◆ R_inv()

const double StandardModel::R_inv ( ) const
virtual

The ratio of the invisible and leptonic (electron) decay widths of the \(Z\) boson, \(R_{inv}\).

\(R_{inv}\) is calculated with

\[ R_{inv} = \frac{\Gamma_{inv}}{\Gamma_e}\,. \]

,

Returns
\(R_{inv} \)

Reimplemented in NPbase.

Definition at line 1556 of file StandardModel/src/StandardModel.cpp.

1557{
1558 return (Gamma_inv() / GammaZ(leptons[ELECTRON]));
1559
1560}

◆ RAq()

double StandardModel::RAq ( const QCD::quark  q) const
protected

The radiator factor associated with the final-state QED and QCD corrections to the the axial-vector-current interactions, \(R_A^q(M_Z^2)\).

See [Chetyrkin:1994js], [Bardin:1999ak], [Bardin:1999yd], [Baikov:2012er] and references therein.

Parameters
[in]qname of a quark (see QCD::quark)
Returns
\(R_A^q(M_Z^2)\)

Definition at line 2277 of file StandardModel/src/StandardModel.cpp.

2278{
2279 if (q == QCD::TOP) return 0.0;
2280
2281 double mcMz, mbMz;
2284 //mcMz = 0.56381685; /* for debug */
2285 //mbMz = 2.8194352; /* for debug */
2286
2287 double MtPole = mtpole;
2288
2289 /* z-component of isospin */
2290 double I3q = quarks[q].getIsospin();
2291 /* electric charge squared */
2292 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2293
2294 /* s = Mz^2 */
2295 double s = Mz * Mz;
2296
2297 /* products of the charm and bottom masses at Mz */
2298 double mcMz2 = mcMz*mcMz;
2299 double mbMz2 = mbMz*mbMz;
2300 double mqMz2, mqdash4;
2301 switch (q) {
2302 case QCD::CHARM:
2303 mqMz2 = mcMz*mcMz;
2304 mqdash4 = mbMz2*mbMz2;
2305 break;
2306 case QCD::BOTTOM:
2307 mqMz2 = mbMz*mbMz;
2308 mqdash4 = mcMz2*mcMz2;
2309 break;
2310 default:
2311 mqMz2 = 0.0;
2312 mqdash4 = 0.0;
2313 break;
2314 }
2315
2316 /* Logarithms */
2317 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2318 double log_t = log(MtPole * MtPole / s); // the pole mass
2319 double log_c = log(mcMz2 / s);
2320 double log_b = log(mbMz2 / s);
2321 double log_q;
2322 switch (q) {
2323 case QCD::CHARM:
2324 case QCD::BOTTOM:
2325 log_q = log(mqMz2 / s);
2326 break;
2327 default:
2328 log_q = 0.0;
2329 break;
2330 }
2331
2332 /* the active number of flavour */
2333 double nf = 5.0;
2334
2335 /* zeta functions */
2336 double zeta2 = getMyEWSMcache()->getZeta2();
2337 double zeta3 = getMyEWSMcache()->getZeta3();
2338 double zeta4 = getMyEWSMcache()->getZeta4();
2339 double zeta5 = getMyEWSMcache()->getZeta5();
2340
2341 /* massless non-singlet corrections */
2342 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2343 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2344 + 275.0 / 6.0 * zeta5
2345 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2346 - 25.0 / 9.0 * zeta5) * nf
2347 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2348 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2349 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2350 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2351 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2352
2353 /* quadratic massive corrections */
2354 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2355 double C20A = -6.0;
2356 double C21A = -22.0;
2357 double C22A = -8221.0 / 24.0 + 57.0 * zeta2 + 117.0 * zeta3
2358 + (151.0 / 12.0 - 2.0 * zeta2 - 4.0 * zeta3) * nf;
2359 double C23A = -4544045.0 / 864.0 + 1340.0 * zeta2 + 118915.0 / 36.0 * zeta3
2360 - 127.0 * zeta5
2361 + (71621.0 / 162.0 - 209.0 / 2.0 * zeta2 - 216.0 * zeta3
2362 + 5.0 * zeta4 + 55.0 * zeta5) * nf
2363 + (-13171.0 / 1944.0 + 16.0 / 9.0 * zeta2 + 26.0 / 9.0 * zeta3) * nf*nf;
2364
2365 /* quartic massive corrections */
2366 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2367 double C40A = 6.0;
2368 double C41A = 10.0;
2369 double C42A = 3389.0 / 12.0 - 162.0 * zeta2 - 220.0 * zeta3
2370 + (-41.0 / 6.0 + 4.0 * zeta2 + 16.0 / 3.0 * zeta3) * nf;
2371 double C42AL = 77.0 / 2.0 - 7.0 / 3.0 * nf;
2372
2373 /* power suppressed top-mass correction */
2374 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2375 double xt = s / MtPole / MtPole; // the pole mass
2376 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2377
2378 /* singlet axial-vector corrections */
2379 double I2 = -37.0 / 12.0 + (-log_t) + 7.0 / 81.0 * xt + 0.0132 * xt*xt;
2380 double I3 = -5075.0 / 216.0 + 23.0 / 6.0 * zeta2 + zeta3 + 67.0 / 18.0 * (-log_t)
2381 + 23.0 / 12.0 * log_t*log_t;
2382 double I4 = 49.0309 - 17.6637 * (-log_t) + 14.6597 * log_t * log_t
2383 + 3.6736 * (-log_t * log_t * log_t);
2384
2385 /* rescaled strong coupling constant */
2386 double AlsMzPi = AlsMz / M_PI;
2387 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2388 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2389 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2390
2391 /* electromagnetic coupling at Mz */
2392 double alpMz = alphaMz();
2393
2394 /* radiator function to the axial-vector current */
2395 double RAf;
2396 RAf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2397 + (C02 + C2t - 2.0 * I3q * I2) * AlsMzPi2
2398 + (C03 - 2.0 * I3q * I3) * AlsMzPi3
2399 + (C04 - 2.0 * I3q * I4) * AlsMzPi4
2400 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2401 + mqMz2 / s * (C20A + C21A * AlsMzPi + C22A * AlsMzPi2
2402 + 6.0 * (3.0 + log_t) * AlsMzPi2 + C23A * AlsMzPi3)
2403 //- 10.0*mqMz2/pow(quarks[TOP].getMass(),2.0)
2404 - 10.0 * mqMz2 / MtPole / MtPole // the pole mass
2405 * (8.0 / 81.0 + log_t / 54.0) * AlsMzPi2
2406 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2407 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2408 + mqMz2 * mqMz2 / s / s * (C40A + C41A * AlsMzPi
2409 + (C42A + C42AL * log_q) * AlsMzPi2)
2410 - 12.0 * mqdash4 / s / s*AlsMzPi2;
2411 return RAf;
2412}
double getZeta4() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:155
double getZeta5() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:164
double getZeta3() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:146
double mf(const Particle f, const double mu=0.0, const orders order=FULLNNLO) const
The mass of an SM fermion.
Definition: EWSMcache.cpp:49
double getZeta2() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:137
double zeta2
computed with the GSL.
Definition: QCD.h:1032
EWSMcache * getMyEWSMcache() const
A get method to retrieve the member pointer of type EWSMcache.

◆ resumKappaZ()

double StandardModel::resumKappaZ ( const double  DeltaRho[orders_EW_size],
const double  deltaKappa_rem[orders_EW_size],
const double  DeltaRbar_rem,
const bool  bool_Zbb 
) const
protected

A method to compute the real part of the effetvive coupling \(\kappa_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\).

This function computes \(\kappa_Z^f\) without or with resummation of \(\Delta\rho\), depending on the model flag KappaZ of StandardModel:

  • NORESUM (recommended):   no resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   this is not applicable to the current function.

where the OMS-I, INTERMEDIATE and OMS-II schemes are adopted in ZFITTER [Bardin:1999yd] (see also [Degrassi:1996mg], [Degrassi:1996ps], [Degrassi:1999jd], [Bardin:1999ak]), and used for making comparisons to the outputs of ZFITTER. In all the cases, the two-loop EW corrections are calculated in the large- \(m_t\) expansion.

Parameters
[in]DeltaRhoArray of \(\Delta\rho\)
[in]deltaKappa_remArray of \(\delta\kappa_{\rm rem}^{f}\)
[in]DeltaRbar_remArray of \(\Delta \bar{r}_{\rm rem}\)
[in]bool_Zbbtrue for \(Zb\bar{b}\)
Returns
\(\mathrm{Re}(\kappa_Z^f)\)

Definition at line 2042 of file StandardModel/src/StandardModel.cpp.

2045{
2046 if ((FlagKappaZ.compare("APPROXIMATEFORMULA") == 0)
2047 || (deltaKappa_rem[EW2QCD1] != 0.0)
2048 || (deltaKappa_rem[EW3] != 0.0))
2049 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2050
2051 if (!flag_order[EW2] && FlagKappaZ.compare("NORESUM") != 0)
2052 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2053
2054 double Mw_TMP = Mw();
2055 double cW2_TMP = cW2();
2056 double sW2_TMP = sW2();
2057
2058 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
2059 double DeltaRbar_rem_G, deltaKappa_rem_G, deltaKappa_rem_G2;
2060 // conversion: alpha(0) --> G_F
2061 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
2062 * sW2_TMP * cW2_TMP / M_PI / ale;
2063 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
2064 + f_AlphaToGF * DeltaRho[EW1QCD1]
2065 + f_AlphaToGF * DeltaRho[EW1QCD2]
2066 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
2067 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
2068 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
2069 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
2070 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
2071 deltaKappa_rem_G = f_AlphaToGF * (deltaKappa_rem[EW1]
2072 + deltaKappa_rem[EW1QCD1]
2073 + deltaKappa_rem[EW1QCD2]);
2074 deltaKappa_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaKappa_rem[EW2];
2075
2076 /* Real parts */
2077 double kappaZ;
2078 if (!bool_Zbb) {
2079 if (FlagKappaZ.compare("OMSI") == 0) {
2080 kappaZ = (1.0 + deltaKappa_rem_G + deltaKappa_rem_G2)
2081 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
2082 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0) {
2083 kappaZ = (1.0 + deltaKappa_rem_G)
2084 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2085 + deltaKappa_rem_G2;
2086 } else if (FlagKappaZ.compare("NORESUM") == 0
2087 || FlagKappaZ.compare("OMSII") == 0) {
2088 kappaZ = 1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2089 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2090 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2091 + deltaKappa_rem_G2;
2092 } else
2093 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2094 } else {
2095 /* Z to bb */
2096 double OnePlusTaub = 1.0 + taub();
2097 double kappaZbL;
2098 deltaKappa_rem_G -= f_AlphaToGF * ale / 8.0 / M_PI / sW2_TMP
2099 * pow(mtpole / Mw_TMP, 2.0);
2100 if (FlagKappaZ.compare("NORESUM") == 0) {
2101 kappaZ = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2102 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2103 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2104 + deltaKappa_rem_G2) / OnePlusTaub;
2105 } else if (FlagKappaZ.compare("OMSI") == 0) {
2106 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2107 kappaZ = kappaZbL * (1.0 + deltaKappa_rem_G);
2108 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0
2109 || FlagKappaZ.compare("OMSII") == 0) {
2110 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2111 kappaZ = kappaZbL + deltaKappa_rem_G;
2112 } else
2113 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2114 }
2115
2116 return kappaZ;
2117}
double taub() const
Top-mass corrections to the vertex, denoted by .

◆ resumMw()

double StandardModel::resumMw ( const double  Mw_i,
const double  DeltaRho[orders_EW_size],
const double  DeltaR_rem[orders_EW_size] 
) const
protected

A method to compute the \(W\)-boson mass from \(\Delta\rho\) and \(\Delta r_{\mathrm{rem}}\).

This function computes the \(W\)-boson mass without or with resummation of \(\Delta r\), depending on the model flag Mw of StandardModel:

  • NORESUM (recommended):   no resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   this is not applicable to the current function.

where the OMS-I, INTERMEDIATE and OMS-II schemes are adopted in ZFITTER [Bardin:1999yd] (see also [Degrassi:1996mg], [Degrassi:1996ps], [Degrassi:1999jd], [Bardin:1999ak]), and used for making comparisons to the outputs of ZFITTER. The full two-loop EW contribution is included in the case of "NORESUM", while the large- \(m_t\) expansion for the two-loop contribution is adopted in the other cases.

In the case of "NORESUM", the two-loop EW contribution to \(\Delta r\) is calculated via the function EWSMApproximateFormulae::DeltaR_TwoLoopEW_rem(), given in the complex-pole/fixed-width scheme. The \(W\)-boson mass in the complex-pole/fixed-width scheme, obtained from \(\Delta r\), is converted into the one in the experimental/running-width scheme with the function MwFromMwbar().

Parameters
[in]Mw_ithe \(W\)-boson mass
[in]DeltaRhoArray of \(\Delta\rho\)
[in]DeltaR_remArray of \(\Delta r_{\mathrm{rem}}\)
Returns
\(M_W\)

Definition at line 1876 of file StandardModel/src/StandardModel.cpp.

1878{
1879 if ((FlagMw.compare("APPROXIMATEFORMULA") == 0)
1880 || (DeltaR_rem[EW2QCD1] != 0.0)
1881 || (DeltaR_rem[EW3] != 0.0))
1882 throw std::runtime_error("Error in StandardModel::resumMw()");
1883
1884 if (!flag_order[EW2] && FlagMw.compare("NORESUM") != 0)
1885 throw std::runtime_error("Error in StandardModel::resumMw()");
1886
1887 double cW2_TMP = Mw_i * Mw_i / Mz / Mz;
1888 double sW2_TMP = 1.0 - cW2_TMP;
1889
1890 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G = 0.0;
1891 if (FlagMw.compare("NORESUM") == 0) {
1892 for (int j = 0; j < orders_EW_size; ++j) {
1893 DeltaRho_sum += DeltaRho[(orders_EW) j];
1894 }
1895 } else {
1896 // conversion: alpha(0) --> G_F
1897 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0) * sW2_TMP * cW2_TMP / M_PI / ale;
1898 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1899 + f_AlphaToGF * DeltaRho[EW1QCD1]
1900 + f_AlphaToGF * DeltaRho[EW1QCD2]
1901 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1902 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1903 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1904 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1905 }
1906
1907 double R;
1908 double DeltaR_rem_sum = 0.0;
1909 double DeltaR_EW1 = 0.0, DeltaR_EW2_rem = 0.0;
1910 if (FlagMw.compare("NORESUM") == 0) {
1911 for (int j = 0; j < orders_EW_size; ++j)
1912 DeltaR_rem_sum += DeltaR_rem[(orders_EW) j];
1913
1914 // Full EW one-loop contribution (without the full DeltaAlphaL5q)
1915 DeltaR_EW1 = -cW2_TMP / sW2_TMP * DeltaRho[EW1] + DeltaR_rem[EW1];
1916
1917 // Full EW two-loop contribution without reducible corrections
1918 DeltaR_EW2_rem = myApproximateFormulae->DeltaR_TwoLoopEW_rem(Mw_i);
1919
1920 // subtract the EW two-loop contributions from DeltaRho_sum and DeltaR_rem_sum
1921 DeltaRho_sum -= DeltaRho[EW2];
1922 DeltaR_rem_sum -= DeltaR_rem[EW2];
1923
1924 // R = 1 + Delta r, including the full EW two-loop contribution
1925 R = 1.0 + DeltaAlphaL5q() - cW2_TMP / sW2_TMP * DeltaRho_sum
1926 + DeltaR_rem_sum;
1927 R += DeltaAlphaL5q() * DeltaAlphaL5q() + 2.0 * DeltaAlphaL5q() * DeltaR_EW1
1928 + DeltaR_EW2_rem;
1929 } else if (FlagMw.compare("OMSI") == 0) {
1930 // R = 1/(1 - Delta r)
1931 R = 1.0 / (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1932 / (1.0 - DeltaAlphaL5q()
1933 - DeltaR_rem[EW1] - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1934 } else if (FlagMw.compare("INTERMEDIATE") == 0) {
1935 // R = 1/(1 - Delta r)
1936 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1937 *(1.0 - DeltaAlphaL5q() - DeltaR_rem[EW1])
1938 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1939 } else if (FlagMw.compare("OMSII") == 0) {
1940 // R = 1/(1 - Delta r)
1941 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)*(1.0 - DeltaAlphaL5q())
1942 - (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G) * DeltaR_rem[EW1]
1943 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1944 } else
1945 throw std::runtime_error("Error in StandardModel::resumMw()");
1946
1947 if (FlagMw.compare("NORESUM") == 0) {
1948 /* Mzbar and Mwbar are defined in the complex-pole scheme. */
1949
1950 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mzbar() / Mzbar();
1951 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1952 double Mwbar = Mzbar() / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R));
1953
1954 return MwFromMwbar(Mwbar);
1955 } else {
1956 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz;
1957 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1958
1959 return (Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R)));
1960 }
1961}
double DeltaR_TwoLoopEW_rem(const double Mw_i) const
.
const double MwFromMwbar(const double Mwbar) const
A method to convert the -boson mass in the complex-pole/fixed-width scheme to that in the experimenta...
orders_EW
An enumerated type representing perturbative orders of radiative corrections to EW precision observab...

◆ resumRhoZ()

double StandardModel::resumRhoZ ( const double  DeltaRho[orders_EW_size],
const double  deltaRho_rem[orders_EW_size],
const double  DeltaRbar_rem,
const bool  bool_Zbb 
) const
protected

A method to compute the real part of the effective coupling \(\rho_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\).

This function computes \(\rho_Z^f\) without or with resummation of \(\Delta\rho\), depending on the model flag RhoZ of StandardModel:

  • NORESUM (recommended):   no resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   this is not applicable to the current function.

where the OMS-I, INTERMEDIATE and OMS-II schemes are adopted in ZFITTER [Bardin:1999yd] (see also [Degrassi:1996mg], [Degrassi:1996ps], [Degrassi:1999jd], [Bardin:1999ak]), and used for making comparisons to the outputs of ZFITTER. In all the cases, the two-loop EW corrections are calculated in the large- \(m_t\) expansion.

Parameters
[in]DeltaRhoArray of \(\Delta\rho\)
[in]deltaRho_remArray of \(\delta\rho_{\rm rem}^{f}\)
[in]DeltaRbar_remArray of \(\Delta \bar{r}_{\rm rem}\)
[in]bool_Zbbtrue for \(Zb\bar{b}\)
Returns
\(\mathrm{Re}(\rho_Z^f)\)

Definition at line 1963 of file StandardModel/src/StandardModel.cpp.

1966{
1967 if ((FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1968 || (deltaRho_rem[EW1QCD2] != 0.0)
1969 || (deltaRho_rem[EW2QCD1] != 0.0)
1970 || (deltaRho_rem[EW3] != 0.0))
1971 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1972
1973 if (!flag_order[EW2] && FlagRhoZ.compare("NORESUM") != 0)
1974 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1975
1976 double Mw_TMP = Mw();
1977 double cW2_TMP = cW2();
1978 double sW2_TMP = sW2();
1979
1980 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
1981 double DeltaRbar_rem_G, deltaRho_rem_G, deltaRho_rem_G2;
1982 // conversion: alpha(0) --> G_F
1983 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
1984 * sW2_TMP * cW2_TMP / M_PI / ale;
1985 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1986 + f_AlphaToGF * DeltaRho[EW1QCD1]
1987 + f_AlphaToGF * DeltaRho[EW1QCD2]
1988 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1989 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1990 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1991 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1992 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
1993 deltaRho_rem_G = f_AlphaToGF * (deltaRho_rem[EW1]
1994 + deltaRho_rem[EW1QCD1]);
1995 deltaRho_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaRho_rem[EW2];
1996
1997 /* Real parts */
1998 double rhoZ;
1999 if (!bool_Zbb) {
2000 if (FlagRhoZ.compare("OMSI") == 0) {
2001 rhoZ = (1.0 + deltaRho_rem_G + deltaRho_rem_G2)
2002 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
2003 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
2004 rhoZ = (1.0 + deltaRho_rem_G)
2005 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2006 + deltaRho_rem_G2;
2007 } else if (FlagRhoZ.compare("NORESUM") == 0
2008 || FlagRhoZ.compare("OMSII") == 0) {
2009 rhoZ = 1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2010 + DeltaRho_G * DeltaRho_G
2011 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2;
2012 } else
2013 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2014 } else {
2015 /* Z to bb */
2016 double OnePlusTaub = 1.0 + taub();
2017 double OnePlusTaub2 = OnePlusTaub*OnePlusTaub;
2018 double rhoZbL;
2019 deltaRho_rem_G += f_AlphaToGF * ale / 4.0 / M_PI / sW2_TMP
2020 * pow(mtpole / Mw_TMP, 2.0);
2021 if (FlagRhoZ.compare("NORESUM") == 0) {
2022 rhoZ = (1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2023 + DeltaRho_G * DeltaRho_G
2024 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2)
2025 * OnePlusTaub2;
2026 } else if (FlagRhoZ.compare("OMSI") == 0) {
2027 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2028 rhoZ = rhoZbL / (1.0 - rhoZbL * deltaRho_rem_G);
2029 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
2030 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2031 rhoZ = rhoZbL * (1.0 + rhoZbL * deltaRho_rem_G);
2032 } else if (FlagRhoZ.compare("OMSII") == 0) {
2033 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2034 rhoZ = rhoZbL * (1.0 + deltaRho_rem_G);
2035 } else
2036 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2037 }
2038
2039 return rhoZ;
2040}

◆ rho_GammaW()

const double StandardModel::rho_GammaW ( const Particle  fi,
const Particle  fj 
) const
virtual

EW radiative corrections to the width of \(W \to f_i \bar{f}_j\), denoted as \(\rho^W_{ij}\).

Parameters
[in]fia lepton or quark
[in]fja lepton or quark
Returns
\(\rho^W_{ij}\)
See also
EWSMOneLoopEW::rho_GammaW()

Definition at line 1240 of file StandardModel/src/StandardModel.cpp.

1241{
1242 double rhoW = 0.0;
1243 if (flag_order[EW1])
1244 rhoW = myOneLoopEW->rho_GammaW(fi, fj, Mw());
1245 return rhoW;
1246}
double rho_GammaW(const Particle fi, const Particle fj, const double Mw_i) const
EW radiative corrections to the width of , denoted as .

◆ rhoZ_f()

const gslpp::complex StandardModel::rhoZ_f ( const Particle  f) const
virtual

The effective leptonic neutral-current coupling \(\rho_Z^l\) in the SM.

This function collects the radiative corrections to \(\rho_Z^l\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes. The real part is computed with the function resumRhoZ(), while only the one-loop contribution is kept in the imaginary part.

Parameters
[in]fa lepton or quark
Returns
\(\rho_{Z,\,\mathrm{SM}}^l\)
See also
resumRhoZ()
Attention
If the model flag CacheInStandardModel of StandardModel is set to true, the caching method implemented in the current class is employed.

Reimplemented in NPbase, and NPEpsilons.

Definition at line 1594 of file StandardModel/src/StandardModel.cpp.

1595{
1596 if (f.getName().compare("TOP") == 0) return (gslpp::complex(0.0, 0.0, false));
1597 if (FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1598 throw std::runtime_error("No approximate formula is available for rhoZ^f");
1599 else {
1600
1602 if (useRhoZ_f_cache[f.getIndex()])
1603 return rhoZ_f_cache[f.getIndex()];
1604
1605 double myMw = Mw();
1606
1607 /* compute Delta rho */
1608 double DeltaRho[orders_EW_size];
1609 ComputeDeltaRho(myMw, DeltaRho);
1610
1611 /* compute delta rho_rem^f */
1612 gslpp::complex deltaRho_remf[orders_EW_size];
1613 deltaRho_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1614 deltaRho_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1615 deltaRho_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1616 deltaRho_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1617 deltaRho_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1618 deltaRho_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1619 if (flag_order[EW1])
1620 deltaRho_remf[EW1] = myOneLoopEW->deltaRho_rem_f(f, myMw);
1621 if (flag_order[EW1QCD1])
1622#ifdef WITHIMTWOLOOPQCD
1623 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(),
1624 myTwoLoopQCD->deltaRho_rem_f(f, myMw).imag(), false);
1625#else
1626 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1627#endif
1628 if (flag_order[EW1QCD2])
1629 deltaRho_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1630 if (flag_order[EW2])
1631 deltaRho_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1632 if (flag_order[EW2QCD1])
1633 deltaRho_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1634 if (flag_order[EW3])
1635 deltaRho_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1636
1637 /* compute Delta rbar_rem */
1638 double DeltaRbar_rem = 0.0;
1639 if (flag_order[EW1])
1640 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1641
1642 /* Re[rho_Z^f] with or without resummation */
1643 double deltaRho_rem_f_real[orders_EW_size];
1644 for (int j = 0; j < orders_EW_size; ++j)
1645 deltaRho_rem_f_real[j] = deltaRho_remf[j].real();
1646 double ReRhoZf = resumRhoZ(DeltaRho, deltaRho_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1647
1648 /* Im[rho_Z^f] without resummation */
1649 double ImRhoZf = 0.0;
1650 for (int j = 0; j < orders_EW_size; ++j)
1651 ImRhoZf += deltaRho_remf[j].imag();
1652
1653 rhoZ_f_cache[f.getIndex()] = gslpp::complex(ReRhoZf, ImRhoZf, false);
1654 useRhoZ_f_cache[f.getIndex()] = true;
1655 return (gslpp::complex(ReRhoZf, ImRhoZf, false));
1656 }
1657}
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
std::string getName() const
Definition: Particle.h:147
double resumRhoZ(const double DeltaRho[orders_EW_size], const double deltaRho_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
A method to compute the real part of the effective coupling from , and .

◆ Ruc()

const double StandardModel::Ruc ( ) const
virtual

Reimplemented in NPbase.

Definition at line 1323 of file StandardModel/src/StandardModel.cpp.

1324{
1325 return 0.5 * ( R0_f(quarks[UP]) + R0_f(quarks[CHARM]) );
1326}

◆ RVh()

double StandardModel::RVh ( ) const
protected

The singlet vector corrections to the hadronic \(Z\)-boson width, denoted as \(R_V^h\).

In addition to the final-state corrections represented by the radiator factors \(R_V^q(M_Z^2)\) and \(R_A^q(M_Z^2)\), there exist singlet vector corrections to the total hadronic width [Chetyrkin:1994js], [Baikov:2012er], which is much smaller than the other corrections.

The assignment of the singlet vector corrections to the partial widths is ambiguous [Bardin:1997xq]. See Gamma_had() for our prescription.

Returns
\(R_V^h\)

Definition at line 2414 of file StandardModel/src/StandardModel.cpp.

2415{
2416 /* rescaled strong coupling constant */
2417 double AlsMzPi = AlsMz / M_PI;
2418 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2419 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2420 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2421
2422 gslpp::complex gV_sum(0.0, 0.0);
2423 gslpp::complex gV_q;
2424 for (int q = 0; q < 6; q++) {
2425 gV_q = gV_f(QCD::quarks[(QCD::quark)q]);
2426 if (q == (int) (QCD::TOP))
2427 gV_q = 0.0;
2428 gV_sum += gV_q;
2429 }
2430
2431 // singlet vector corrections
2432 return ( gV_sum.abs2()*(-0.4132 * AlsMzPi3 - 4.9841 * AlsMzPi4));
2433}

◆ RVq()

double StandardModel::RVq ( const QCD::quark  q) const
protected

The radiator factor associated with the final-state QED and QCD corrections to the the vector-current interactions, \(R_V^q(M_Z^2)\).

See [Chetyrkin:1994js], [Bardin:1999ak], [Bardin:1999yd] and references therein.

Parameters
[in]qname of a quark (see QCD::quark)
Returns
\(R_V^q(M_Z^2)\)

Definition at line 2157 of file StandardModel/src/StandardModel.cpp.

2158{
2159 if (q == QCD::TOP) return 0.0;
2160
2161 double mcMz, mbMz;
2164 //mcMz = 0.56381685; /* for debug */
2165 //mbMz = 2.8194352; /* for debug */
2166
2167 double MtPole = mtpole;
2168
2169 /* electric charge squared */
2170 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2171
2172 /* s = Mz^2 */
2173 double s = Mz * Mz;
2174
2175 /* products of the charm and bottom masses at Mz */
2176 double mcMz2 = mcMz*mcMz;
2177 double mbMz2 = mbMz*mbMz;
2178 double mqMz2, mqdash4;
2179 switch (q) {
2180 case QCD::CHARM:
2181 mqMz2 = mcMz*mcMz;
2182 mqdash4 = mbMz2*mbMz2;
2183 break;
2184 case QCD::BOTTOM:
2185 mqMz2 = mbMz*mbMz;
2186 mqdash4 = mcMz2*mcMz2;
2187 break;
2188 default:
2189 mqMz2 = 0.0;
2190 mqdash4 = 0.0;
2191 break;
2192 }
2193
2194 /* Logarithms */
2195 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2196 double log_t = log(MtPole * MtPole / s); // the pole mass
2197 double log_c = log(mcMz2 / s);
2198 double log_b = log(mbMz2 / s);
2199 double log_q;
2200 switch (q) {
2201 case QCD::CHARM:
2202 case QCD::BOTTOM:
2203 log_q = log(mqMz2 / s);
2204 break;
2205 default:
2206 log_q = 0.0;
2207 break;
2208 }
2209
2210 /* the active number of flavour */
2211 double nf = 5.0;
2212
2213 /* zeta functions */
2214 double zeta2 = getMyEWSMcache()->getZeta2();
2215 double zeta3 = getMyEWSMcache()->getZeta3();
2216 //double zeta4 = getMyCache()->GetZeta4();
2217 double zeta5 = getMyEWSMcache()->getZeta5();
2218
2219 /* massless non-singlet corrections */
2220 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2221 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2222 + 275.0 / 6.0 * zeta5
2223 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2224 - 25.0 / 9.0 * zeta5) * nf
2225 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2226 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2227 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2228 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2229 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2230
2231 /* quadratic massive corrections */
2232 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2233 double C21V = 12.0;
2234 double C22V = 253.0 / 2.0 - 13.0 / 3.0 * nf;
2235 double C23V = 2522.0 - 855.0 / 2.0 * zeta2 + 310.0 / 3.0 * zeta3 - 5225.0 / 6.0 * zeta5
2236 + (-4942.0 / 27.0 + 34.0 * zeta2 - 394.0 / 27.0 * zeta3
2237 + 1045.0 / 27.0 * zeta5) * nf
2238 + (125.0 / 54.0 - 2.0 / 3.0 * zeta2) * nf*nf;
2239
2240 /* quartic massive corrections */
2241 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2242 double C40V = -6.0;
2243 double C41V = -22.0;
2244 double C42V = -3029.0 / 12.0 + 162.0 * zeta2 + 112.0 * zeta3
2245 + (143.0 / 18.0 - 4.0 * zeta2 - 8.0 / 3.0 * zeta3) * nf;
2246 double C42VL = -11.0 / 2.0 + nf / 3.0;
2247
2248 /* power suppressed top-mass correction */
2249 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2250 double xt = s / MtPole / MtPole; // the pole mass
2251 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2252
2253 /* rescaled strong coupling constant */
2254 double AlsMzPi = AlsMz / M_PI;
2255 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2256 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2257 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2258
2259 /* electromagnetic coupling at Mz */
2260 double alpMz = alphaMz();
2261
2262 /* radiator function to the vector current */
2263 double RVf;
2264 RVf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2265 + (C02 + C2t) * AlsMzPi2 + C03 * AlsMzPi3 + C04 * AlsMzPi4
2266 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2267 + mqMz2 / s * (C21V * AlsMzPi + C22V * AlsMzPi2 + C23V * AlsMzPi3)
2268 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2269 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2270 + mqMz2 * mqMz2 / s / s * (C40V + C41V * AlsMzPi + (C42V + C42VL * log_q) * AlsMzPi2)
2271 + 12.0 * mqdash4 / s / s * AlsMzPi2
2272 - mqMz2 * mqMz2 * mqMz2 / s / s / s
2273 * (8.0 + 16.0 / 27.0 * (155.0 + 6.0 * log_q) * AlsMzPi);
2274 return RVf;
2275}

◆ RWc()

const double StandardModel::RWc ( ) const
virtual

The ratio \(R_{W,c)=\Gamma(W\to c + X)/\Gamma(W\to had)\).

Returns
\(R_{W,c)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1328 of file StandardModel/src/StandardModel.cpp.

1329{
1330 double GammWcX, GammWhad;
1331
1332// Add all the W-> cX decays
1333// In GammaW fermion masses are ignored and CKM=1 but uses that SM CKM is unitary => I only need W->cs
1334 GammWcX = GammaW(quarks[CHARM], quarks[STRANGE]);
1335
1336// For the same reasons, I only need to add the W-> ud decays into the hadronic part
1337 GammWhad = GammWcX
1338 + GammaW(quarks[UP], quarks[DOWN]);
1339
1340 return GammWcX/GammWhad;
1341}

◆ RWlilj()

const double StandardModel::RWlilj ( const Particle  li,
const Particle  lj 
) const
virtual

The lepton universality ratio \(R_{W,l_i/l_j)=\Gamma(W\to l_i \nu_i)/\Gamma(W\to l_j \nu_j)\).

Returns
\(R_{W,l_i/l_j)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1298 of file StandardModel/src/StandardModel.cpp.

1299{
1300 double GammWli, GammWlj;
1301
1302 if (li.is("ELECTRON"))
1303 GammWli = GammaW(leptons[NEUTRINO_1],li);
1304 else if (li.is("MU"))
1305 GammWli = GammaW(leptons[NEUTRINO_2],li);
1306 else if (li.is("TAU"))
1307 GammWli = GammaW(leptons[NEUTRINO_3],li);
1308 else
1309 throw std::runtime_error("Error in StandardModel::RWlilj. li must be a charged lepton");
1310
1311 if (lj.is("ELECTRON"))
1312 GammWlj = GammaW(leptons[NEUTRINO_1],lj);
1313 else if (lj.is("MU"))
1314 GammWlj = GammaW(leptons[NEUTRINO_2],lj);
1315 else if (lj.is("TAU"))
1316 GammWlj = GammaW(leptons[NEUTRINO_3],lj);
1317 else
1318 throw std::runtime_error("Error in StandardModel::RWlilj. lj must be a charged lepton");
1319
1320 return GammWli/GammWlj;
1321}

◆ RZlilj()

const double StandardModel::RZlilj ( const Particle  li,
const Particle  lj 
) const
virtual

The lepton universality ratio \(R_{Z,l_i/l_j)=\Gamma(Z\to l_i^+ l_i^-)/\Gamma(Z\to l_j^+ l_j^-)\).

Returns
\(R_{Z,l_i/l_j)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1453 of file StandardModel/src/StandardModel.cpp.

1454{
1455 double GammZli, GammZlj;
1456
1457 if ( li.is("ELECTRON") || li.is("MU") || li.is("TAU") )
1458 GammZli = GammaZ(li);
1459 else
1460 throw std::runtime_error("Error in StandardModel::RZlilj. li must be a charged lepton");
1461
1462 if ( lj.is("ELECTRON") || lj.is("MU") || lj.is("TAU") )
1463 GammZlj = GammaZ(lj);
1464 else
1465 throw std::runtime_error("Error in StandardModel::RZlilj. lj must be a charged lepton");
1466
1467 return GammZli/GammZlj;
1468}

◆ s02()

const double StandardModel::s02 ( ) const

The square of the sine of the weak mixing angle \(s_0^2\) defined without weak radiative corrections.

The quantity \(s_0^2\) is defined through

\[ s_0^2 c_0^2 = \frac{\pi\,\alpha(M_Z^2)}{\sqrt{2}\,G_\mu M_Z^2} \ \ \rightarrow\ \ s_0^2 = \frac{1}{2} \left(1 - \sqrt{1 - \frac{4\pi \alpha(M_Z^2)}{\sqrt{2}\,G_\mu M_Z^2}}\ \right)\,. \]

See [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(s_0^2\)

Definition at line 1011 of file StandardModel/src/StandardModel.cpp.

1012{
1013 double tmp = 1.0 - 4.0 * M_PI * alphaMz() / sqrt(2.0) / GF / Mz / Mz;
1014 if (tmp < 0.0)
1015 throw std::runtime_error("Error in s02()");
1016
1017 return ( (1.0 - sqrt(tmp)) / 2.0);
1018}

◆ SchemeToDouble()

double StandardModel::SchemeToDouble ( const std::string  scheme) const
inlineprotected

A method to convert a given scheme name in string form into a floating-point number with double precision.

This method is used in EWSM::checkSMparams() for caching the schemes used in computing \(M_W\), \(\rho_Z^f\) and \(\kappa_Z^f\).

Parameters
[in]schemescheme name that is used in computing \(M_W\), \(\rho_Z^f\) or \(\kappa_Z^f\)
Returns
a floating-point number with double precision corresponding to the given scheme name

Definition at line 3531 of file StandardModel.h.

3532 {
3533 if (scheme.compare("NORESUM") == 0)
3534 return 0.0;
3535 else if (scheme.compare("OMSI") == 0)
3536 return 1.0;
3537 else if (scheme.compare("INTERMEDIATE") == 0)
3538 return 2.0;
3539 else if (scheme.compare("OMSII") == 0)
3540 return 3.0;
3541 else if (scheme.compare("APPROXIMATEFORMULA") == 0)
3542 return 4.0;
3543 else
3544 throw std::runtime_error("EWSM::SchemeToDouble: bad scheme");
3545 }

◆ setCKM()

void StandardModel::setCKM ( const CKM CKMMatrix)
inline

A set method to change the CKM matrix.

Parameters
[in]CKMMatrixa reference to the new CKM matrix

Definition at line 3360 of file StandardModel.h.

3361 {
3362 myCKM = CKMMatrix;
3363 }

◆ setFlag()

bool StandardModel::setFlag ( const std::string  name,
const bool  value 
)
virtual

A method to set a flag of StandardModel.

Parameters
[in]namename of a model flag
[in]valuethe boolean to be assigned to the flag specified by name
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, HiggsChiral, HiggsKigen, NPbase, NPd6SILH, NPEpsilons, NPSMEFTd6, NPSMEFTd6General, THDM, GeorgiMachacek, LeftRightSymmetricModel, NPSMEFT6dtopquark, and SUSY.

Definition at line 449 of file StandardModel/src/StandardModel.cpp.

450{
451 bool res = false;
452 if (name.compare("CacheInStandardModel") == 0) {
454 res = true;
455 } else if (name.compare("CacheInEWSMcache") == 0) {
457 res = true;
458 } else if (name.compare("Wolfenstein") == 0) {
459 FlagWolfenstein = value;
460 if(!FlagWolfenstein) {
461 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"lambda"))] = "V_us";
462 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"A"))] = "V_cb";
463 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"rhob"))] = "V_ub";
464 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"etab"))] = "gamma";
465
466 ModelParamMap.insert(std::make_pair("V_us", std::cref(Vus)));
467 ModelParamMap.insert(std::make_pair("V_cb", std::cref(Vcb)));
468 ModelParamMap.insert(std::make_pair("V_ub", std::cref(Vub)));
469 ModelParamMap.insert(std::make_pair("gamma", std::cref(gamma)));
470 }
471 res = true;
472 } else if (name.compare("WithoutNonUniversalVC") == 0) {
474 res = true;
475 } else if (name.compare("NoApproximateGammaZ") == 0) {
477 res = true;
478 } else if (name.compare("MWinput") == 0) {
479 FlagMWinput = value;
480 if (FlagMWinput) {
481 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"dAle5Mz"))] = "Mw_inp";
482 ModelParamMap.insert(std::make_pair("Mw_inp", std::cref(Mw_inp)));
483 // Point the different flags towards the approximate formulae, when available
485 FlagMw = "APPROXIMATEFORMULA";
486 FlagRhoZ = "NORESUM";
487 FlagKappaZ = "APPROXIMATEFORMULA";
488 }
489 res = true;
490 } else if (name.compare("SMAux") == 0) {
491 FlagSMAux = value;
492 res = true;
493 } else if (name.compare("FixMuwMut") == 0) {
494 FlagFixMuwMut = value;
495 res = true;
496 } else if (name.compare("UseVud") == 0) {
497 FlagUseVud = value;
499 throw std::runtime_error("UseVud can only be used when Wolfenstein is false");
500 else if(FlagUseVud) {
501 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"V_us"))] = "V_ud";
502 ModelParamMap.erase("V_us");
503 ModelParamMap.insert(std::make_pair("V_ud", std::cref(Vud)));
504 }
505 res = true;
506 } else
507 res = QCD::setFlag(name, value);
508
509 if (!res) res = SMFlavour.setFlag(name, value);
510
511 return (res);
512}
void setFlagCacheInEWSMcache(bool FlagCacheInEWSMcache)
A set method to change the model flag CacheInEWSMcache in StandardModel.
Definition: EWSMcache.h:83
bool setFlag(const std::string name, const bool value)
Definition: Flavour.cpp:37
std::string name
The name of the model.
Definition: Model.h:285
virtual bool setFlag(const std::string name, const bool value)
A method to set a flag of QCD.
Definition: QCD.cpp:479
void setFlagCacheInStandardModel(bool FlagCacheInStandardModel)
A set method to change the model flag CacheInStandardModel of StandardModel.

◆ setFlagCacheInStandardModel()

void StandardModel::setFlagCacheInStandardModel ( bool  FlagCacheInStandardModel)
inline

A set method to change the model flag CacheInStandardModel of StandardModel.

Setting CacheInStandardModel to false, the caching methods defined in the current class are not employed in numerical computations. The flag is set to true in the constructor EWSM() by default.

Parameters
[in]FlagCacheInStandardModeltrue (false) if the caching methods are turned on (off);
See also
the description of the StandardModel flags

Definition at line 742 of file StandardModel.h.

◆ setFlagNoApproximateGammaZ()

void StandardModel::setFlagNoApproximateGammaZ ( bool  FlagNoApproximateGammaZ)
inline

Definition at line 696 of file StandardModel.h.

◆ setFlagSigmaForAFB()

bool StandardModel::setFlagSigmaForAFB ( const bool  flagSigmaForAFB_i)
inline

Definition at line 3324 of file StandardModel.h.

3325{
3326 bSigmaForAFB = flagSigmaForAFB_i;
3327 return true;
3328}

◆ setFlagSigmaForR()

bool StandardModel::setFlagSigmaForR ( const bool  flagSigmaForR_i)
inline

Definition at line 3330 of file StandardModel.h.

3331{
3332 bSigmaForR = flagSigmaForR_i;
3333 return true;
3334}

◆ setFlagStr()

bool StandardModel::setFlagStr ( const std::string  name,
const std::string  value 
)
virtual

A method to set a flag of StandardModel.

Parameters
[in]namename of a model flag
[in]valuethe string to be assigned to the flag specified by name
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in LeftRightSymmetricModel, NPSMEFTd6General, THDM, and THDMW.

Definition at line 514 of file StandardModel/src/StandardModel.cpp.

515{
516 bool res = false;
517 if (name.compare("Mw") == 0) {
518 if (checkEWPOscheme(value)) {
519 FlagMw = value;
520 res = true;
521 } else
522 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
523 + name + "=" + value);
524
525 } else if (name.compare("RhoZ") == 0) {
526 if (checkEWPOscheme(value)) {
527 FlagRhoZ = value;
528 res = true;
529 } else
530 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
531 + name + "=" + value);
532 } else if (name.compare("KappaZ") == 0) {
533 if (checkEWPOscheme(value)) {
534 FlagKappaZ = value;
535 res = true;
536 } else
537 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
538 + name + "=" + value);
539 } else
540 res = QCD::setFlagStr(name, value);
541
542 if (FlagMWinput) {
543 // Point the different flags towards the approximate formulae, when available
545 FlagMw = "APPROXIMATEFORMULA";
546 FlagRhoZ = "NORESUM";
547 FlagKappaZ = "APPROXIMATEFORMULA";
548 }
549
550 return (res);
551}
virtual bool setFlagStr(const std::string name, const std::string value)
A method to set a flag of QCD.
Definition: QCD.cpp:511
bool checkEWPOscheme(const std::string scheme) const
A method to check if a given scheme name in string form is valid.

◆ setParameter()

void StandardModel::setParameter ( const std::string  name,
const double &  value 
)
protectedvirtual

A method to set the value of a parameter of StandardModel.

Parameters
[in]namename of a model parameter
[in]valuethe value to be assigned to the parameter specified by name

Reimplemented from QCD.

Reimplemented in NPDF2, HiggsChiral, HiggsKigen, NPd6SILH, NPEpsilons, NPEpsilons_pureNP, NPHiggs, NPSMEFT6dtopquark, NPSMEFTd6, NPSMEFTd6General, NPSMEFTd6U2, NPSMEFTd6U2qU1le, NPSMEFTd6U3, NPSTU, NPSTUVWXY, NPSTUZbbbarLR, NPZbbbar, NPZbbbarLinearized, SigmaBR, SUSY, THDM, CMFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, pMSSM, SUSYMassInsertion, and THDMW.

Definition at line 280 of file StandardModel/src/StandardModel.cpp.

281{
282 if (name.compare("Mz") == 0) {
283 Mz = value;
284 QCD::setParameter("MAls", value);
285 } else if (name.compare("AlsMz") == 0) {
286 AlsMz = value;
287 QCD::setParameter("AlsM", value);
288 } else if (name.compare("GF") == 0)
289 GF = value;
290 else if (name.compare("ale") == 0)
291 ale = value;
292 else if (name.compare("dAle5Mz") == 0 && !FlagMWinput)
293 dAle5Mz = value;
294 else if (name.compare("Mw_inp") == 0 && FlagMWinput)
295 Mw_inp = value;
296 else if (name.compare("mHl") == 0)
297 mHl = value;
298 else if (name.compare("delMw") == 0)
299 delMw = value;
300 else if (name.compare("delSin2th_l") == 0)
301 delSin2th_l = value;
302 else if (name.compare("delSin2th_q") == 0)
303 delSin2th_q = value;
304 else if (name.compare("delSin2th_b") == 0)
305 delSin2th_b = value;
306 else if (name.compare("delGammaZ") == 0)
307 delGammaZ = value;
308 else if (name.compare("delsigma0H") == 0)
309 delsigma0H = value;
310 else if (name.compare("delR0l") == 0)
311 delR0l = value;
312 else if (name.compare("delR0c") == 0)
313 delR0c = value;
314 else if (name.compare("delR0b") == 0)
315 delR0b = value;
316 else if (name.compare("delGammaWlv") == 0)
317 delGammaWlv = value;
318 else if (name.compare("delGammaWqq") == 0)
319 delGammaWqq = value;
320 else if (name.compare("mneutrino_1") == 0)
321 leptons[NEUTRINO_1].setMass(value);
322 else if (name.compare("mneutrino_2") == 0)
323 leptons[NEUTRINO_2].setMass(value);
324 else if (name.compare("mneutrino_3") == 0)
325 leptons[NEUTRINO_3].setMass(value);
326 else if (name.compare("melectron") == 0)
327 leptons[ELECTRON].setMass(value);
328 else if (name.compare("mmu") == 0)
329 leptons[MU].setMass(value);
330 else if (name.compare("mtau") == 0)
331 leptons[TAU].setMass(value);
332 else if (name.compare("lambda") == 0 && FlagWolfenstein) {
333 lambda = value;
334 requireCKM = true;
335 } else if (name.compare("A") == 0 && FlagWolfenstein) {
336 A = value;
337 requireCKM = true;
338 } else if (name.compare("rhob") == 0 && FlagWolfenstein) {
339 rhob = value;
340 requireCKM = true;
341 } else if (name.compare("etab") == 0 && FlagWolfenstein) {
342 etab = value;
343 requireCKM = true;
344 } else if (name.compare("V_us") == 0 && !FlagWolfenstein && !FlagUseVud) {
345 Vus = value;
346 requireCKM = true;
347 } else if (name.compare("V_ud") == 0 && !FlagWolfenstein && FlagUseVud) {
348 Vud = value;
349 requireCKM = true;
350 } else if (name.compare("V_cb") == 0 && !FlagWolfenstein) {
351 Vcb = value;
352 requireCKM = true;
353 } else if (name.compare("V_ub") == 0 && !FlagWolfenstein) {
354 Vub = value;
355 requireCKM = true;
356 } else if (name.compare("gamma") == 0 && !FlagWolfenstein) {
357 gamma = value;
358 requireCKM = true;
359 } else if (name.compare("muw") == 0) {
360 /* Update mut if FlagFixMuwMut is activated */
361 muw = value;
362 if (FlagFixMuwMut) {
363 mut = muw / 80.4 * 163.;
364 }
365 }
366 else
367 QCD::setParameter(name, value);
368}
void setMass(double mass)
A set method to fix the particle mass.
Definition: Particle.h:70
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of QCD.
Definition: QCD.cpp:343

◆ setRequireCKM()

void StandardModel::setRequireCKM ( bool  requireCKM)
inline

A set method to change the value of requireCKM.

Parameters
[in]requireCKMthe new value for requireCKM

Definition at line 3351 of file StandardModel.h.

3352 {
3353 this->requireCKM = requireCKM;
3354 }

◆ setSMSuccess()

void StandardModel::setSMSuccess ( bool  success) const
inline

A set method to change the success status of the Standard Model update and matching.

Parameters
[in]successthe new value for SMSuccess

Definition at line 3438 of file StandardModel.h.

3439 {
3440 SMSuccess = success;
3441 }

◆ setYd()

void StandardModel::setYd ( const gslpp::matrix< gslpp::complex > &  Yd)
inline

A set method to set the Yukawa matrix of the down-type quarks, \(Y_d\).

Parameters
[in]Ydthe Yukawa matrix to be set

Definition at line 3400 of file StandardModel.h.

3401 {
3402 this->Yd = Yd;
3403 }

◆ setYe()

void StandardModel::setYe ( const gslpp::matrix< gslpp::complex > &  Ye)
inline

A set method to set the Yukawa matrix of the charged leptons, \(Y_e\).

Parameters
[in]Yethe Yukawa matrix to be set

Definition at line 3420 of file StandardModel.h.

3421 {
3422 this->Ye = Ye;
3423 }

◆ setYu()

void StandardModel::setYu ( const gslpp::matrix< gslpp::complex > &  Yu)
inline

A set method to set the Yukawa matrix of the up-type quarks, \(Y_u\).

Parameters
[in]Yuthe Yukawa matrix to be set

Definition at line 3380 of file StandardModel.h.

3381 {
3382 this->Yu = Yu;
3383 }

◆ sigma0_had()

const double StandardModel::sigma0_had ( ) const
virtual

The hadronic cross section for \(e^+e^- \to Z \to \mathrm{hadrons}\) at the \(Z\)-pole, \(\sigma_h^0\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(\sigma_h^0\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, the hadronic cross section is calculated with

\[ \sigma_h^0 = \frac{12\pi}{M_Z^2}\frac{\Gamma_e\Gamma_h}{\Gamma_Z^2}\,. \]

Returns
\(\sigma_h^0\) in GeV \(^{-2}\)

Reimplemented in NPbase, NPEpsilons, NPSMEFTd6General, and NPZbbbar.

Definition at line 1471 of file StandardModel/src/StandardModel.cpp.

1472{
1474
1475 /* SM contribution with the approximate formula */
1476 return (myApproximateFormulae->X_full("sigmaHadron")
1477 / GeVminus2_to_nb);
1478
1479 } else {
1480 return (12.0 * M_PI * GammaZ(leptons[ELECTRON]) * Gamma_had()
1481 / Mz / Mz / Gamma_Z() / Gamma_Z());
1482 }
1483}
static const double GeVminus2_to_nb

◆ sigma_NoISR_l()

const double StandardModel::sigma_NoISR_l ( const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8007 of file StandardModel/src/StandardModel.cpp.

8008{
8009 double ml = getLeptons(l_flavor).getMass();
8010 double l_charge = getLeptons(l_flavor).getCharge();
8011 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8012
8013 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8014 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, l_charge);
8015
8016 return sigma;
8017}

◆ sigma_NoISR_q()

const double StandardModel::sigma_NoISR_q ( const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8019 of file StandardModel/src/StandardModel.cpp.

8020{
8021 double mq = m_q(q_flavor, sqrt(s));
8022 double q_charge = getQuarks(q_flavor).getCharge();
8023 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8024
8025 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8026 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, q_charge);
8027
8028 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8030
8031 return sigma;
8032}

◆ SigmaeeHee()

const double StandardModel::SigmaeeHee ( const double  sqrt_s,
const double  Pe,
const double  Pp 
) const
virtual

The \(\sigma(e^+ e^- \to e^+ e^- H)\) in the Standard Model.

Currently, only at tree level. From https://arxiv.org/pdf/hep-ph/9605437

Returns
\(\sigma(e^+ e^- \to e^+ e^- H)\) in the Standard Model

Definition at line 3357 of file StandardModel/src/StandardModel.cpp.

3358{
3359 double xsLH=0.0, xsRH=0.0;
3360
3361 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3362}

◆ SigmaeeHvv()

const double StandardModel::SigmaeeHvv ( const double  sqrt_s,
const double  Pe,
const double  Pp 
) const
virtual

The \(\sigma(e^+ e^- \to \nu \bar{\nu} H)\) in the Standard Model.

Currently, only at tree level. From https://arxiv.org/pdf/hep-ph/9605437

Returns
\(\sigma(e^+ e^- \to \nu \bar{\nu} H)\) in the Standard Model

Definition at line 3350 of file StandardModel/src/StandardModel.cpp.

3351{
3352 double xsLH=1.0, xsRH=0.0;
3353
3354 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3355}

◆ SigmaeeZH()

const double StandardModel::SigmaeeZH ( const double  sqrt_s,
const double  Pe,
const double  Pp 
) const
virtual

The \(\sigma(e^+ e^- \to Z H)\) in the Standard Model.

Currently, only at tree level. From https://arxiv.org/pdf/hep-ph/9605437

Returns
\(\sigma(e^+ e^- \to Z H)\) in the Standard Model

Definition at line 3328 of file StandardModel/src/StandardModel.cpp.

3329{
3330 double xsLH, xsRH;
3331 double gL,gR,lam,fact;
3332 double s = sqrt_s*sqrt_s;
3333
3334 // From https://arxiv.org/pdf/hep-ph/9605437
3335
3336 gL = -0.5 + sW2();
3337
3338 gR = sW2();
3339
3340 lam = (1.0-(mHl+Mz)*(mHl+Mz)/s)*(1.0-(mHl-Mz)*(mHl-Mz)/s);
3341
3342 fact = (pow(GF*Mz*Mz,2.0)/96.0/M_PI/s) * sqrt(lam)*( lam + 12.0*Mz*Mz/s )/( 1.0 - Mz*Mz/s )/( 1.0 - Mz*Mz/s );
3343
3344 xsLH = 32.0 * gL * gL * fact;
3345 xsRH = 32.0 * gR * gR * fact;
3346
3347 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3348}

◆ sin2thetaEff()

const double StandardModel::sin2thetaEff ( const Particle  f) const
virtual

The effective weak mixing angle \(\sin^2\theta_{\rm eff}^{\,\ell}\) for \(Z\ell\bar{\ell}\) at the the \(Z\)-mass scale.

When checkNPZff_linearized() returns true and the model flag KappaZ of StandardModel is set to APPROXIMATEFORMULA, this function uses the two-loop approximate formula of \(\sin^2\theta_{\rm eff}^{\,\ell}\) via EWSMApproximateFormulae::sin2thetaEff(). Otherwise, the effective weak mixing angle is calculated from the coupling \(\kappa_Z^\ell\):

\[ \sin^2\theta_{\rm eff}^{\,\ell} = {\rm Re}(\kappa_Z^\ell)\,s_W^2\,. \]

Parameters
[in]fa lepton or quark
Returns
\(\sin^2\theta_{\rm eff}^{\,\ell}\)
Attention
\(\ell\) stands for both a neutrino and a charged lepton.

Reimplemented in NPbase, NPZbbbar, and NPEpsilons.

Definition at line 1357 of file StandardModel/src/StandardModel.cpp.

1358{
1359 double Re_kappa = kappaZ_f(f).real();
1360 return ( Re_kappa * sW2());
1361}

◆ sW2() [1/2]

const double StandardModel::sW2 ( ) const

Definition at line 1098 of file StandardModel/src/StandardModel.cpp.

1099{
1100 return ( 1.0 - cW2());
1101}

◆ sW2() [2/2]

const double StandardModel::sW2 ( const double  Mw_i) const
virtual

The square of the sine of the weak mixing angle in the on-shell scheme, denoted as \(s_W^2\).

\[ s_W^2=\sin^2{\theta_W}=1-\frac{M_W^2}{M_Z^2}. \]

Returns
\(s_W^2\)

Definition at line 1093 of file StandardModel/src/StandardModel.cpp.

1094{
1095 return ( 1.0 - cW2(Mw_i));
1096}

◆ sW2_MSbar_Approx()

const double StandardModel::sW2_MSbar_Approx ( ) const

The (approximated formula for the) square of the sine of the weak mixing angle in the MSbar scheme, denoted as \(\hat{s}_{W}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022)

Returns
\(\hat{s}_{W}^2\)

Definition at line 1103 of file StandardModel/src/StandardModel.cpp.

1104{
1105 //double rho_t= 3. * getGF() * getMtpole() * getMtpole() / (8. * sqrt(2.) * M_PI * M_PI );
1106 return ( sW2()*1.0351 ); //PDG 22 electroweak review eq. (10.19)
1107}

◆ sW2_ND()

const double StandardModel::sW2_ND ( ) const

The square of the sine of the weak mixing angle in the MSbar-ND scheme (w/o decoupling $\alpha\ln(m_t/M_Z)$ terms), denoted as \(\hat{s}_{ND}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022) (eq. 10.13a/10.13b)

Returns
\(\hat{s}_{ND}^2\)

Definition at line 1109 of file StandardModel/src/StandardModel.cpp.

1110{
1111 double d = 1. / 3. * (1. / sW2_MSbar_Approx() - 8. / 3.) *
1112 ( (1 + getAlsMz()/M_PI)*log(getMtpole()/getMz()) - 15.*getAlsMz()/(8.*M_PI) );
1113
1114 return sW2_MSbar_Approx()*(1. + Ale(getMz(),FULLNLO)*d/M_PI);
1115
1116}
const double getMtpole() const
A get method to access the pole mass of the top quark.
Definition: QCD.h:600
const double sW2_MSbar_Approx() const
The (approximated formula for the) square of the sine of the weak mixing angle in the MSbar scheme,...
const double getMz() const
A get method to access the mass of the boson .
const double getAlsMz() const
A get method to access the value of .

◆ taub()

double StandardModel::taub ( ) const
protected

Top-mass corrections to the \(Zb\bar{b}\) vertex, denoted by \(\tau_b\).

The large top-quark mass gives important corrections to the EW observables through the gauge-boson self-energies, i.e., \(\Delta\rho\), and through the \(Zb\bar{b}\) vertex. The latter contribution is parameterised by the quantity \(\tau_b\):

\[ \tau_{b} = -2\, X_t^{G_\mu} \left[ 1 - \frac{\pi}{3}\alpha_s(M^2_t) + X_t^{G_\mu} \tau^{(2)} \left( \frac{M_t^2}{m_h^2} \right) \right], \]

where the \(O(G_\mu\alpha_s m_t^2)\) term was calculated in [Fleischer:1992fq], [Buchalla:1992zm], [Degrassi:1993ij], [Chetyrkin:1993jp], and the \(O(G_\mu^2 m_t^4)\) term can be found in [Barbieri:1992nz], [Barbieri:1992dq], [Fleischer:1993ub], [Fleischer:1994cb].

Returns
\(\tau_b\)

Definition at line 2119 of file StandardModel/src/StandardModel.cpp.

2120{
2121 double taub_tmp = 0.0;
2122 double Xt = myEWSMcache->Xt_GF();
2123 if (flag_order[EW1])
2124 taub_tmp += -2.0 * Xt;
2125 if (flag_order[EW1QCD1])
2126 taub_tmp += 2.0 / 3.0 * M_PI * Xt * myEWSMcache->alsMt();
2127 if (flag_order[EW1QCD2])
2128 taub_tmp += 0.0;
2129 if (flag_order[EW2])
2130 taub_tmp += -2.0 * Xt * Xt * myTwoLoopEW->tau_2();
2131 if (flag_order[EW2QCD1])
2132 taub_tmp += 0.0;
2133 if (flag_order[EW3])
2134 taub_tmp += 0.0;
2135
2136 return taub_tmp;
2137}
double tau_2() const
The function .
double Xt_GF() const
The quantity with the coupling .
Definition: EWSMcache.h:343
double alsMt() const
The strong coupling at NNLO.
Definition: EWSMcache.h:378

◆ TauLFU_gmuge()

const double StandardModel::TauLFU_gmuge ( ) const
virtual

The computation of the LFU ratio \(g_\mu/ g_e \).

Returns
\(g_\mu/ g_e \)

Reimplemented in NPbase.

Definition at line 3171 of file StandardModel/src/StandardModel.cpp.

3172{
3173 double g2LFU;
3174
3175 double me, mmu, mtau, xe, Fxe, xmu, Fxmu;
3176
3177 me = leptons[ELECTRON].getMass();
3178 mmu = leptons[MU].getMass();
3179 mtau = leptons[TAU].getMass();
3180
3181 xe = me*me/mtau/mtau;
3182 Fxe = 1. - 8. * xe + 8. * xe*xe*xe - xe*xe*xe*xe -12. * xe*xe * log(xe);
3183
3184 xmu = mmu*mmu/mtau/mtau;
3185 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3186
3188
3189 g2LFU = g2LFU * (Fxe/Fxmu);
3190
3191 return sqrt(g2LFU);
3192}
virtual const double Gamma_tau_l_nunu(const Particle l) const
The computation of the leptonic tau decays.

◆ TauLFU_gtauge()

const double StandardModel::TauLFU_gtauge ( ) const
virtual

The computation of the LFU ratio \(g_\tau/ g_e \).

Returns
\(g_\tau/ g_e \)

Reimplemented in NPbase.

Definition at line 3217 of file StandardModel/src/StandardModel.cpp.

3218{
3219 double g2LFU;
3220
3221 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3222
3223 me = leptons[ELECTRON].getMass();
3224 mmu = leptons[MU].getMass();
3225 mtau = leptons[TAU].getMass();
3226
3227 xtau = mmu*mmu/mtau/mtau;
3228 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3229
3230 xmu = me*me/mmu/mmu;
3231 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3232
3233 g2LFU = (Gamma_tau_l_nunu(leptons[MU])/Gamma_muon());
3234
3235 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3236
3237 return sqrt(g2LFU);
3238}
virtual const double Gamma_muon() const
The computation of the muon decay.

◆ TauLFU_gtaugmu()

const double StandardModel::TauLFU_gtaugmu ( ) const
virtual

The computation of the LFU ratio \(g_\tau/ g_\mu \).

Returns
\(g_\tau/ g_\mu \)

Reimplemented in NPbase.

Definition at line 3194 of file StandardModel/src/StandardModel.cpp.

3195{
3196 double g2LFU;
3197
3198 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3199
3200 me = leptons[ELECTRON].getMass();
3201 mmu = leptons[MU].getMass();
3202 mtau = leptons[TAU].getMass();
3203
3204 xtau = me*me/mtau/mtau;
3205 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3206
3207 xmu = me*me/mmu/mmu;
3208 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3209
3211
3212 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3213
3214 return sqrt(g2LFU);
3215}

◆ TauLFU_gtaugmuK()

const double StandardModel::TauLFU_gtaugmuK ( ) const
virtual

The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_K \).

Returns
\(\left(g_\tau/ g_\mu\right)_K \)

Reimplemented in NPbase.

Definition at line 3248 of file StandardModel/src/StandardModel.cpp.

3249{
3250 // 1st approx.
3251
3252 return 1.0;
3253}

◆ TauLFU_gtaugmuPi()

const double StandardModel::TauLFU_gtaugmuPi ( ) const
virtual

The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_\pi \).

Returns
\(\left(g_\tau/ g_\mu\right)_\pi \)

Reimplemented in NPbase.

Definition at line 3241 of file StandardModel/src/StandardModel.cpp.

3242{
3243 // 1st approx.
3244
3245 return 1.0;
3246}

◆ ThetaLnuN()

const double StandardModel::ThetaLnuN ( ) const
virtual

The effective neutrino nucleon LH parameter: ThetaLnuN.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(\theta_L(\nu N)\)

Definition at line 3034 of file StandardModel/src/StandardModel.cpp.

3035{
3036 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3038
3039 /* SM contribution with the approximate formula */
3041
3042 } else {
3043 throw std::runtime_error("ERROR: StandardModel::ThetaLnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3044 }
3045}
double LEThetaLnuNApprox() const
The effective neutrino nucleon LH parameter: ThetaLnuN.

◆ ThetaRnuN()

const double StandardModel::ThetaRnuN ( ) const
virtual

The effective neutrino nucleon RH parameter: ThetaRnuN.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(\theta_R(\nu N)\)

Definition at line 3048 of file StandardModel/src/StandardModel.cpp.

3049{
3050 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3052
3053 /* SM contribution with the approximate formula */
3055
3056 } else {
3057 throw std::runtime_error("ERROR: StandardModel::ThetaRnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3058 }
3059}
double LEThetaRnuNApprox() const
The effective neutrino nucleon RH parameter: ThetaRnuN.

◆ tovers2()

const double StandardModel::tovers2 ( const double  cosmin,
const double  cosmax 
) const

Definition at line 3918 of file StandardModel/src/StandardModel.cpp.

3918 {
3919 return 0.25 * (cosmax * (1.0 - cosmax * (1.0 - cosmax / 3.0)) - cosmin * (1.0 - cosmin * (1.0 - cosmin / 3.0)));
3920}

◆ uovers2()

const double StandardModel::uovers2 ( const double  cosmin,
const double  cosmax 
) const

Definition at line 3922 of file StandardModel/src/StandardModel.cpp.

3922 {
3923 return 0.25 * (cosmax * (1.0 + cosmax * (1.0 + cosmax / 3.0)) - cosmin * (1.0 + cosmin * (1.0 + cosmin / 3.0)));
3924}

◆ Update()

bool StandardModel::Update ( const std::map< std::string, double > &  DPars)
virtual

The update method for StandardModel.

This method updates all the model parameters with given DPars.

Parameters
[in]DParsa map of the parameters that are being updated in the Monte Carlo run (including parameters that are varied and those that are held constant)
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPbase, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 227 of file StandardModel/src/StandardModel.cpp.

228{
229 if (!PreUpdate()) return (false);
230
231 UpdateError = false;
232
233 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
234 setParameter(it->first, it->second);
235
236 if (UpdateError) return (false);
237
238 if (!PostUpdate()) return (false);
239
240 return (true);
241}
bool UpdateError
A boolean set to false if update is successful.
Definition: Model.h:272
virtual bool PreUpdate()
The pre-update method for StandardModel.
virtual bool PostUpdate()
The post-update method for StandardModel.
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of StandardModel.

◆ v()

const double StandardModel::v ( ) const

The Higgs vacuum expectation value.

\[ v = \left(\frac{1}{\sqrt{2} G_\mu}\right)^{1/2}, \]

where \(G_\mu\) is the Fermi constant, measured through muon decays.

Returns
\(v\) in GeV

Definition at line 995 of file StandardModel/src/StandardModel.cpp.

996{
997 return ( 1. / sqrt(sqrt(2.) * GF));
998}

Member Data Documentation

◆ A

double StandardModel::A
protected

The CKM parameter \(A\) in the Wolfenstein parameterization.

Definition at line 3496 of file StandardModel.h.

◆ ale

double StandardModel::ale
protected

The fine-structure constant \(\alpha\).

Definition at line 3481 of file StandardModel.h.

◆ ale_cache

double StandardModel::ale_cache[10][CacheSize]
mutableprivate

Cache for \(\alpha_e\).

Definition at line 4114 of file StandardModel.h.

◆ alpha21

double StandardModel::alpha21
protected

Definition at line 3505 of file StandardModel.h.

◆ alpha31

double StandardModel::alpha31
protected

Definition at line 3505 of file StandardModel.h.

◆ als_cache

double StandardModel::als_cache[11][CacheSize]
mutableprivate

Cache for \(\alpha_s\).

Definition at line 4113 of file StandardModel.h.

◆ AlsMz

double StandardModel::AlsMz
protected

The strong coupling constant at the Z-boson mass, \(\alpha_s(M_Z)\).

Definition at line 3477 of file StandardModel.h.

◆ average

double StandardModel::average
mutableprivate

GSL integral variable

Definition at line 4099 of file StandardModel.h.

◆ bSigmaForAFB

bool StandardModel::bSigmaForAFB
mutableprotected

Definition at line 3763 of file StandardModel.h.

◆ bSigmaForR

bool StandardModel::bSigmaForR
mutableprotected

Definition at line 3764 of file StandardModel.h.

◆ CacheSize

const int StandardModel::CacheSize = 5
staticprivate

Defines the depth of the cache.

Definition at line 4112 of file StandardModel.h.

◆ dAl5hMz

double StandardModel::dAl5hMz
protected

The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\). (Non-input parameter)

Definition at line 3508 of file StandardModel.h.

◆ dAle5Mz

double StandardModel::dAle5Mz
protected

The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\), used as input for FlagMWinput = FALSE.

Definition at line 3482 of file StandardModel.h.

◆ delGammaWlv

double StandardModel::delGammaWlv
protected

The theoretical uncertainty in \(\Gamma_W_{l\nu}\), denoted as \(\delta\,\Gamma_W_{l\nu}\).

Definition at line 3493 of file StandardModel.h.

◆ delGammaWqq

double StandardModel::delGammaWqq
protected

The theoretical uncertainty in \(\Gamma_W_{qq}\), denoted as \(\delta\,\Gamma_W_{qq}\).

Definition at line 3494 of file StandardModel.h.

◆ delGammaZ

double StandardModel::delGammaZ
protected

The theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\), in GeV.

Definition at line 3488 of file StandardModel.h.

◆ delMw

double StandardModel::delMw
protected

The theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\), in GeV.

Definition at line 3484 of file StandardModel.h.

◆ delR0b

double StandardModel::delR0b
protected

The theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\).

Definition at line 3492 of file StandardModel.h.

◆ delR0c

double StandardModel::delR0c
protected

The theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\).

Definition at line 3491 of file StandardModel.h.

◆ delR0l

double StandardModel::delR0l
protected

The theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\).

Definition at line 3490 of file StandardModel.h.

◆ delsigma0H

double StandardModel::delsigma0H
protected

The theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\) in nb.

Definition at line 3489 of file StandardModel.h.

◆ delSin2th_b

double StandardModel::delSin2th_b
protected

The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\).

Definition at line 3487 of file StandardModel.h.

◆ delSin2th_l

double StandardModel::delSin2th_l
protected

The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\).

Definition at line 3485 of file StandardModel.h.

◆ delSin2th_q

double StandardModel::delSin2th_q
protected

The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\).

Definition at line 3486 of file StandardModel.h.

◆ delta

double StandardModel::delta
protected

Definition at line 3505 of file StandardModel.h.

◆ DeltaAlpha_cache

double StandardModel::DeltaAlpha_cache
mutableprivate

A cache of the value of \(\Delta\alpha(M_Z^2)\).

Definition at line 4080 of file StandardModel.h.

◆ DeltaAlphaLepton_cache

double StandardModel::DeltaAlphaLepton_cache
mutableprivate

A cache of the value of \(\Delta\alpha_{\mathrm{lept}}(M_Z^2)\).

Definition at line 4079 of file StandardModel.h.

◆ error

double StandardModel::error
mutableprivate

GSL integral variable

Definition at line 4100 of file StandardModel.h.

◆ etab

double StandardModel::etab
protected

The CKM parameter \(\bar{\eta}\) in the Wolfenstein parameterization.

Definition at line 3498 of file StandardModel.h.

◆ f_GSL

gsl_function StandardModel::f_GSL
mutableprivate

GSL integral variable

Definition at line 4101 of file StandardModel.h.

◆ flag_order

bool StandardModel::flag_order[orders_EW_size]
protected

An array of internal flags controlling the inclusions of higher-order corrections.

These flags are prepared for debugging. The flags are initialized in the constructor EWSM().

Definition at line 3519 of file StandardModel.h.

◆ FlagCacheInStandardModel

bool StandardModel::FlagCacheInStandardModel
private

A flag for caching (true by default).

Definition at line 4077 of file StandardModel.h.

◆ FlagFixMuwMut

bool StandardModel::FlagFixMuwMut
protected

A boolean for the model flag FixMuwMut.

Definition at line 3753 of file StandardModel.h.

◆ FlagKappaZ

std::string StandardModel::FlagKappaZ
private

A string for the model flag KappaZ.

Definition at line 4065 of file StandardModel.h.

◆ flagLEP2

bool StandardModel::flagLEP2[NUMofLEP2RCs]
protected

Definition at line 3762 of file StandardModel.h.

◆ FlagMw

std::string StandardModel::FlagMw
private

A string for the model flag Mw.

Definition at line 4063 of file StandardModel.h.

◆ FlagMWinput

bool StandardModel::FlagMWinput
private

A boolean for the model flag MWinput.

Definition at line 4069 of file StandardModel.h.

◆ FlagNoApproximateGammaZ

bool StandardModel::FlagNoApproximateGammaZ
private

A boolean for the model flag NoApproximateGammaZ.

Definition at line 4062 of file StandardModel.h.

◆ FlagRhoZ

std::string StandardModel::FlagRhoZ
private

A string for the model flag RhoZ.

Definition at line 4064 of file StandardModel.h.

◆ FlagSMAux

bool StandardModel::FlagSMAux
private

A boolean for the model flag SMAux.

Definition at line 4070 of file StandardModel.h.

◆ FlagUseVud

bool StandardModel::FlagUseVud
private

A boolean for the model flag UseVud.

Definition at line 4067 of file StandardModel.h.

◆ FlagWithoutNonUniversalVC

bool StandardModel::FlagWithoutNonUniversalVC
private

A boolean for the model flag WithoutNonUniversalVC.

Definition at line 4061 of file StandardModel.h.

◆ FlagWolfenstein

bool StandardModel::FlagWolfenstein
private

A boolean for the model flag Wolfenstein.

Definition at line 4066 of file StandardModel.h.

◆ gamma

double StandardModel::gamma
protected

\(\gamma \) used as an input for FlagWolfenstein = FALSE

Definition at line 3503 of file StandardModel.h.

◆ GammaW_cache

double StandardModel::GammaW_cache
mutableprivate

A cache of the value of \(\Gamma_W\).

Definition at line 4082 of file StandardModel.h.

◆ GeVminus2_to_nb

const double StandardModel::GeVminus2_to_nb = 389379.338
static

Definition at line 558 of file StandardModel.h.

◆ GF

double StandardModel::GF
protected

The Fermi constant \(G_\mu\) in \({\rm GeV}^{-2}\).

Definition at line 3480 of file StandardModel.h.

◆ iterationNo

int StandardModel::iterationNo
private

Definition at line 4105 of file StandardModel.h.

◆ kappaZ_f_cache

gslpp::complex StandardModel::kappaZ_f_cache[12]
mutableprivate

A cache of the value of \(\kappa_Z^l\).

Definition at line 4084 of file StandardModel.h.

◆ lambda

double StandardModel::lambda
protected

The CKM parameter \(\lambda\) in the Wolfenstein parameterization.

Definition at line 3495 of file StandardModel.h.

◆ leptons

Particle StandardModel::leptons[6]
protected

An array of Particle objects for the leptons.

Definition at line 3464 of file StandardModel.h.

◆ mHl

double StandardModel::mHl
protected

The Higgs mass \(m_h\) in GeV.

Definition at line 3483 of file StandardModel.h.

◆ muw

double StandardModel::muw
protected

A matching scale \(\mu_W\) around the weak scale in GeV.

Definition at line 3504 of file StandardModel.h.

◆ Mw_cache

double StandardModel::Mw_cache
mutableprivate

A cache of the value of \(M_W\).

Definition at line 4081 of file StandardModel.h.

◆ Mw_error

const double StandardModel::Mw_error = 0.00001
static

The target accuracy of the iterative calculation of the \(W\)-boson mass in units of GeV.

Definition at line 564 of file StandardModel.h.

◆ Mw_inp

double StandardModel::Mw_inp
protected

The mass of the \(W\) boson in GeV used as input for FlagMWinput = TRUE.

Definition at line 3479 of file StandardModel.h.

◆ myApproximateFormulae

EWSMApproximateFormulae* StandardModel::myApproximateFormulae
private

A pointer to an object of type EWSMApproximateFormulae.

Definition at line 4055 of file StandardModel.h.

◆ myCKM

CKM StandardModel::myCKM
protected

An object of type CKM.

Definition at line 3465 of file StandardModel.h.

◆ myEWSMcache

EWSMcache* StandardModel::myEWSMcache
private

A pointer to an object of type EWSMcache.

Definition at line 4048 of file StandardModel.h.

◆ myLeptonFlavour

LeptonFlavour* StandardModel::myLeptonFlavour
private

A pointer to an object of the type LeptonFlavour.

Definition at line 4056 of file StandardModel.h.

◆ myOneLoopEW

EWSMOneLoopEW* StandardModel::myOneLoopEW
private

A pointer to an object of type EWSMOneLoopEW.

Definition at line 4049 of file StandardModel.h.

◆ myPMNS

PMNS StandardModel::myPMNS
protected

Definition at line 3466 of file StandardModel.h.

◆ myThreeLoopEW

EWSMThreeLoopEW* StandardModel::myThreeLoopEW
private

A pointer to an object of type EWSMThreeLoopEW.

Definition at line 4054 of file StandardModel.h.

◆ myThreeLoopEW2QCD

EWSMThreeLoopEW2QCD* StandardModel::myThreeLoopEW2QCD
private

A pointer to an object of type EWSMThreeLoopEW2QCD.

Definition at line 4053 of file StandardModel.h.

◆ myThreeLoopQCD

EWSMThreeLoopQCD* StandardModel::myThreeLoopQCD
private

A pointer to an object of type EWSMThreeLoopQCD.

Definition at line 4051 of file StandardModel.h.

◆ myTwoFermionsLEP2

EWSMTwoFermionsLEP2* StandardModel::myTwoFermionsLEP2
private

A pointer to an object of type EWSMTwoFermionsLEP2.

Definition at line 4058 of file StandardModel.h.

◆ myTwoLoopEW

EWSMTwoLoopEW* StandardModel::myTwoLoopEW
private

A pointer to an object of type EWSMTwoLoopEW.

Definition at line 4052 of file StandardModel.h.

◆ myTwoLoopQCD

EWSMTwoLoopQCD* StandardModel::myTwoLoopQCD
private

A pointer to an object of type EWSMTwoLoopQCD.

Definition at line 4050 of file StandardModel.h.

◆ Mz

double StandardModel::Mz
protected

The mass of the \(Z\) boson in GeV.

Definition at line 3478 of file StandardModel.h.

◆ NSMvars

const int StandardModel::NSMvars = 28
static

The number of the model parameters in StandardModel.

Definition at line 552 of file StandardModel.h.

◆ NumSMParamsForEWPO

const int StandardModel::NumSMParamsForEWPO = 35
static

The number of the SM parameters that are relevant to the EW precision observables.

This constant is used for the cashing method.

See also
checkSMparamsForEWPO()

Definition at line 2132 of file StandardModel.h.

◆ realorder

orders StandardModel::realorder
mutableprivate

Definition at line 4115 of file StandardModel.h.

◆ requireCKM

bool StandardModel::requireCKM
protected

An internal flag to control whether the CKM matrix has to be recomputed.

Definition at line 3748 of file StandardModel.h.

◆ requireYe

bool StandardModel::requireYe
protected

An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed.

Definition at line 3749 of file StandardModel.h.

◆ requireYn

bool StandardModel::requireYn
protected

An internal flag to control whether the neutrino Yukawa matrix has to be recomputed.

Definition at line 3750 of file StandardModel.h.

◆ rhob

double StandardModel::rhob
protected

The CKM parameter \(\bar{\rho}\) in the Wolfenstein parameterization.

Definition at line 3497 of file StandardModel.h.

◆ rhoZ_f_cache

gslpp::complex StandardModel::rhoZ_f_cache[12]
mutableprivate

A cache of the value of \(\rho_Z^l\).

Definition at line 4083 of file StandardModel.h.

◆ s12

double StandardModel::s12
protected

Definition at line 3505 of file StandardModel.h.

◆ s13

double StandardModel::s13
protected

Definition at line 3505 of file StandardModel.h.

◆ s23

double StandardModel::s23
protected

Definition at line 3505 of file StandardModel.h.

◆ SMFlavour

Flavour StandardModel::SMFlavour
protected

An object of type Flavour.

Definition at line 3752 of file StandardModel.h.

◆ SMM

Matching<StandardModelMatching,StandardModel> StandardModel::SMM
mutableprotected

An object of type Matching.

Definition at line 3469 of file StandardModel.h.

◆ SMparamsForEWPO_cache

double StandardModel::SMparamsForEWPO_cache[NumSMParamsForEWPO]
mutableprivate

Definition at line 4078 of file StandardModel.h.

◆ SMresult_cache

double StandardModel::SMresult_cache
mutableprivate

Definition at line 4095 of file StandardModel.h.

◆ SMSuccess

bool StandardModel::SMSuccess
mutableprivate

A boolean for the success of the Standard Model update and matching.

Definition at line 4072 of file StandardModel.h.

◆ SMvars

std::string StandardModel::SMvars
static
Initial value:
= {
"lambda", "A", "rhob", "etab", "Mz", "AlsMz", "GF", "ale", "dAle5Mz", "mHl",
"delMw", "delSin2th_l", "delSin2th_q", "delSin2th_b", "delGammaZ", "delsigma0H", "delR0l", "delR0c", "delR0b", "delGammaWlv", "delGammaWqq",
"mneutrino_1", "mneutrino_2", "mneutrino_3", "melectron", "mmu", "mtau", "muw"
}

A string array containing the labels of the model parameters in StandardModel.

Definition at line 556 of file StandardModel.h.

◆ useDeltaAlpha_cache

bool StandardModel::useDeltaAlpha_cache
mutableprivate

Definition at line 4086 of file StandardModel.h.

◆ useDeltaAlphaLepton_cache

bool StandardModel::useDeltaAlphaLepton_cache
mutableprivate

Definition at line 4085 of file StandardModel.h.

◆ useGammaW_cache

bool StandardModel::useGammaW_cache
mutableprivate

Definition at line 4088 of file StandardModel.h.

◆ useKappaZ_f_cache

bool StandardModel::useKappaZ_f_cache[12]
mutableprivate

Definition at line 4090 of file StandardModel.h.

◆ useMw_cache

bool StandardModel::useMw_cache
mutableprivate

Definition at line 4087 of file StandardModel.h.

◆ useRhoZ_f_cache

bool StandardModel::useRhoZ_f_cache[12]
mutableprivate

Definition at line 4089 of file StandardModel.h.

◆ Vcb

double StandardModel::Vcb
protected

\(\vert V_{cb} \vert \) used as an input for FlagWolfenstein = FALSE

Definition at line 3501 of file StandardModel.h.

◆ Vub

double StandardModel::Vub
protected

\(\vert V_{ub} \vert \) used as an input for FlagWolfenstein = FALSE

Definition at line 3502 of file StandardModel.h.

◆ Vud

double StandardModel::Vud
protected

\(\vert V_{ud} \vert \) used as an input for FlagWolfenstein = FALSE and FlagUseVud = TRUE

Definition at line 3500 of file StandardModel.h.

◆ Vus

double StandardModel::Vus
protected

\(\vert V_{us} \vert \) used as an input for FlagWolfenstein = FALSE

Definition at line 3499 of file StandardModel.h.

◆ w_GSL1

gsl_integration_workspace* StandardModel::w_GSL1
private

GSL integral variable

Definition at line 4102 of file StandardModel.h.

◆ Yd

gslpp::matrix<gslpp::complex> StandardModel::Yd
protected

The Yukawa matrix of the down-type quarks.

Definition at line 3471 of file StandardModel.h.

◆ Ye

gslpp::matrix<gslpp::complex> StandardModel::Ye
protected

The Yukawa matrix of the charged leptons.

Definition at line 3473 of file StandardModel.h.

◆ Yn

gslpp::matrix<gslpp::complex> StandardModel::Yn
protected

The Yukawa matrix of the neutrinos.

Definition at line 3472 of file StandardModel.h.

◆ Yu

gslpp::matrix<gslpp::complex> StandardModel::Yu
protected

The Yukawa matrix of the up-type quarks.

Definition at line 3470 of file StandardModel.h.


The documentation for this class was generated from the following files: